test-patient-generator 1.0.2 → 1.1.0

data/Gemfile

@@ -1,15 +1,13 @@
 source "http://rubygems.org"
 
-gem 'hqmf-parser', '~> 1.0.6'
-gem 'hquery-patient-api', '~> 0.3.0'
-gem 'hqmf2js', '~> 1.0.1'
-gem 'health-data-standards', '~> 2.1.4'
+gemspec
 
 gem 'rake'
-gem 'pry'
-gem 'pry-nav'
-gem 'bson_ext'
 
 group :test do
   gem 'simplecov'
-end
+  gem 'turn'
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'pry-stack_explorer'
+end

data/lib/test-patient-generator.rb

@@ -1,16 +1,11 @@
 require 'hqmf-parser'
 require 'health-data-standards'
+require 'qrda_generator'
 
 require_relative 'tpg/ext/coded'
-require_relative 'tpg/ext/conjunction'
 require_relative 'tpg/ext/data_criteria'
-require_relative 'tpg/ext/derivation_operator'
-require_relative 'tpg/ext/population_criteria'
-require_relative 'tpg/ext/precondition'
 require_relative 'tpg/ext/range'
 require_relative 'tpg/ext/record'
-require_relative 'tpg/ext/subset_operator'
-require_relative 'tpg/ext/temporal_reference'
 require_relative 'tpg/ext/value'
 
 require_relative 'tpg/generation/generator'

data/lib/tpg/ext/coded.rb

@@ -15,6 +15,11 @@ module HQMF
       code_sets
     end
     
+    # Filter through a list of value sets and choose only the ones marked with a given OID.
+    #
+    # @param [String] oid The OID being used for filtering.
+    # @param [Array] value_sets A pool of available value sets
+    # @return The value set from the list with the requested OID.
     def self.select_value_sets(oid, value_sets)
       # Pick the value set for this DataCriteria. If it can't be found, it is an error from the value set source. We'll add the entry without codes for now.
       index = value_sets.index{|value_set| value_set["oid"] == oid}
@@ -30,10 +35,11 @@ module HQMF
     # @return A Hash including a code and code system containing one randomly selected code.
     def self.select_code(oid, value_sets)
       codes = select_codes(oid, value_sets)
-      codeSystem = codes.keys()[0]
+      code_system = codes.keys()[0]
+      return nil if code_system.nil?
       {
-        'codeSystem' => codeSystem,
-        'code' => codes[codeSystem][0]
+        'code_system' => code_system,
+        'code' => codes[code_system][0]
       }
     end
   end

data/lib/tpg/ext/data_criteria.rb

@@ -1,163 +1,171 @@
 module HQMF
   class DataCriteria
-    attr_accessor :generation_range, :values
-
-    # Generate all acceptable ranges of values and times for this data criteria. These ranges will then be updated by the permutate function 
-    # and passed to modify_patient to actually augment the base_patients Records.
-    # 
-    # @param [Array] base_patients The list of patients who will be augmented by this data criteria.
-    # @return The updated list of patients. The array will be modified by reference already so this is just for potential convenience.
-    def generate(base_patients)
-      acceptable_times = []
-
-      # Evaluate all of the temporal restrictions on this data criteria.
-      unless temporal_references.nil?
-        # Generate for patients based on each reference and merge the potential times together.
-        temporal_references.each do |reference|
-          acceptable_time = reference.generate(base_patients)
-          acceptable_times = DerivationOperator.intersection(acceptable_time, acceptable_times)
-        end
-      end
-      
-      # Apply any subset operators (e.g. FIRST)
-      # e.g., if the subset operator is THIRD we need to make at least three entries
-      unless subset_operators.nil?
-        subset_operators.each do |subset_operator|
-          subset_operator.generate(base_patients)
-        end
-      end
-      
-      # Apply any derivation operator (e.g. UNION)
-      unless derivation_operator.nil?
-        Range.merge(DerivationOperator.generate(base_patients, children_criteria, derivation_operator), acceptable_times)
+    attr_accessor :values
+
+    # Modify a Record with this data criteria.
+    #
+    # @param [Record] patient The Record that is being modified. 
+    # @param [Range] time The period of time during which the data criteria happens.
+    # @param [Hash] value_sets The value sets that this data criteria references.
+    # @return The modified patient.
+    def modify_patient(patient, time, value_sets)
+      # Modify the patient with a characteristic if this data criteria defines one
+      modify_patient_with_characteristic(patient, time, value_sets)
+
+      # Otherwise we're dealing with a data criteria that describes a coded entry, so we create it and add it to the patient
+      entry = derive_entry(time, value_sets)
+      modify_entry_with_values(entry, value_sets)
+      modify_entry_with_negation(entry, value_sets)
+      modify_entry_with_fields(entry, value_sets)
+      modify_patient_with_entry(patient, entry)
+    end
+
+    private
+
+    # Modify a Record with a data criteria that describes a patient characteristic.
+    #
+    # @param [Record] patient The Record that is being modified. 
+    # @param [Range] time The period of time during which the data criteria happens.
+    # @param [Hash] value_sets The value sets that this data criteria references.
+    # @return The modified patient.
+    def modify_patient_with_characteristic(patient, time, value_sets)
+      return nil unless characteristic?
+
+      if property == :birthtime
+        patient.birthdate = time.low.to_seconds
+      elsif property == :gender
+        gender = value.code
+        patient.gender = gender
+        patient.first = Randomizer.randomize_first_name(gender)
+      elsif property == :clinicalTrialParticipant
+        patient.clinicalTrialParticipant = true
+      elsif property == :expired
+        patient.expired = true
+        patient.deathdate = time.high.to_seconds
       end
-      
-      # Set the acceptable ranges for this data criteria so any parents can read it
-      @generation_range = acceptable_times
+    end
 
-      # Calculate value information
-      acceptable_values = []
-      acceptable_values << value
-      
-      # Walk through all acceptable time/value combinations and alter out patients
-      base_patients.each do |patient|
-        acceptable_times.each do |time|
-          acceptable_values.each do |value|
-            modify_patient(patient, time, Generator.value_sets)
-          end
+    # Determine the apporpriate coded entry type from this data criteria and create one to match.
+    #
+    # @param [Range] time The period of time during which the entry happens.
+    # @param [Hash] value_sets The value sets that this data criteria references.
+    # @return A coded entry with basic data defined by this data criteria.
+    def derive_entry(time, value_sets)
+      return nil if characteristic?
+
+      entry_type = Generator.classify_entry(patient_api_function)
+      entry = entry_type.classify.constantize.new
+      entry.description = "#{description} (Code List: #{code_list_id})"
+      entry.start_time = time.low.to_seconds if time.low
+      entry.end_time = time.high.to_seconds if time.high
+      entry.status = status
+      entry.codes = Coded.select_codes(code_list_id, value_sets)
+      entry.oid = HQMF::DataCriteria.template_id_for_definition(definition, status, negation)
+      entry
+    end
+
+    # Add any value related data to a coded entry from this data criteria.
+    #
+    # @param [Entry] entry The coded entry that this data criteria is defining.
+    # @param [Hash] value_sets The value sets that this data criteria references.
+    # @return The modified coded entry.
+    def modify_entry_with_values(entry, value_sets)
+      return nil unless entry.present? && values.present?
+
+      # If the value itself has a code, it will be a Coded type. Otherwise, it's just a regular value with a unit.
+      entry.values ||= []
+      values.each do |value|
+        if value.type == "CD"
+          entry.values << CodedResultValue.new({codes: Coded.select_codes(value.code_list_id, value_sets), description: HQMF::Coded.select_value_sets(value.code_list_id, value_sets)["concept"]})
+        else
+          entry.values << PhysicalQuantityResultValue.new(value.format)
         end
       end
-      
-      base_patients
     end
-    
-    # 
+
+    # Mark a coded entry as negated if this data criteria describes it as such.
     #
-    # @param [Array] acceptable_times
-    # @param [Array] acceptable_values
-    def permutate(acceptable_times, acceptable_values)
+    # @param [Entry] entry The coded entry that this data criteria is potentially negating.
+    # @param [Hash] value_sets The value sets that this data criteria references.
+    # @return The modified coded entry.
+    def modify_entry_with_negation(entry, value_sets)
+      return nil unless entry.present? && negation && negation_code_list_id.present?
       
+      entry.negation_ind = true
+      entry.negation_reason = Coded.select_code(negation_code_list_id, value_sets)
     end
-    
-    # Modify a Record with this data criteria. Acceptable times and values are defined prior to this function.
+
+    # Add this data criteria's field related data to a coded entry.
     #
-    # @param [Record] patient The Record that is being modified. 
-    # @param [Range] time An acceptable range of times for the coded entry being put on this patient.
+    # @param [Entry] entry The coded entry that this data criteria is modifying.
     # @param [Hash] value_sets The value sets that this data criteria references.
-    # @return The modified patient. The passed in patient object will be modified by reference already so this is just for potential convenience.
-    def modify_patient(patient, time, value_sets)
-      # Figure out what kind of data criteria we're looking at
-      if type == :characteristic and property != nil and patient_api_function == nil
-        # We have a special case on our hands.
-        if property == :birthtime
-          patient.birthdate = time.low.to_seconds
-        elsif value.present? && value.system == "Gender"
-          patient.gender = value.code
-          patient.first = Randomizer.randomize_first_name(value.code)
-        elsif property == :clinicalTrialParticipant
-          patient.clinicalTrialParticipant = true
-        end
-      else
-        # Otherwise this is a regular coded entry. Start by choosing the correct type and assigning basic metadata.
-        entry_type = Generator.classify_entry(patient_api_function)
-        
-        # HACK -- this is here to deal with types that have not been mapped yet and blow things up
-        return patient if entry_type.nil? || entry_type == ""
-        entry = entry_type.classify.constantize.new
-
-        entry.description = "#{description} (Code List: #{code_list_id})"
-        entry.start_time = time.low.to_seconds if time.low
-        entry.end_time = time.high.to_seconds if time.high
-        entry.status = status
-        entry.codes = Coded.select_codes(code_list_id, value_sets)
-        entry.oid = HQMF::DataCriteria.template_id_for_definition(definition, status, negation)
-
-        # If the value itself has a code, it will be a Coded type. Otherwise, it's just a regular value with a unit.
-        if value.present? && !value.is_a?(AnyValue)
-          entry.values ||= []
-          if value.type == "CD"
-            entry.values << CodedResultValue.new({codes: Coded.select_codes(value.code_list_id, value_sets)})
-          else
-            entry.values << PhysicalQuantityResultValue.new(value.format)
-          end
-        end
-        
-        if values.present?
-           entry.values ||= []
-           values.each do |value|
-             if value.type == "CD"
-               entry.values << CodedResultValue.new({codes: Coded.select_codes(value.code_list_id, value_sets), description: Coded.select_value_sets(value.code_list_id, value_sets)['description']})
-             else
-               entry.values << PhysicalQuantityResultValue.new(value.format)
-             end
-           end
+    # @return The modified coded entry.
+    def modify_entry_with_fields(entry, value_sets)
+      return nil unless entry.present? && field_values.present?
+
+      field_values.each do |name, field|
+        next if field.nil?
+
+        # Format the field to be stored in a Record.
+        if field.type == "CD"
+          field_value = Coded.select_code(field.code_list_id, value_sets)
+          field_value["title"] = HQMF::Coded.select_value_sets(field.code_list_id, value_sets)["concept"]
+        else
+          field_value = field.format
         end
         
-        # Choose a code from each relevant code vocabulary for this entry's negation, if it is negated and referenced.
-        if negation && negation_code_list_id.present?
-          entry.negation_ind = true
-          entry.negation_reason = Coded.select_code(negation_code_list_id, value_sets)
+        field_accessor = nil
+        # Facilities are a special case where we store a whole object on the entry in Record. Create or augment the existing facility with this piece of data.
+        if name.include? "FACILITY"
+          facility = entry.facility
+          facility ||= Facility.new
+          facility_map = {"FACILITY_LOCATION" => :code, "FACILITY_LOCATION_ARRIVAL_DATETIME" => :start_time, "FACILITY_LOCATION_DEPARTURE_DATETIME" => :end_time}
+          
+          facility.name = field.title if type == "CD"
+          facility_accessor = facility_map[name]
+          facility.send("#{facility_accessor}=", field_value)
+          
+          field_accessor = :facility
+          field_value = facility
         end
-        
-        # Additional fields (e.g. ordinality, severity, etc) seem to all be special cases. Capture them here.
-        if field_values.present?
-          field_values.each do |name, field|
-            next if field.nil?
-            
-            # These fields are sometimes Coded and sometimes Values.
-            if field.type == "CD"
-              codes = Coded.select_codes(field.code_list_id, value_sets)
-            elsif field.type == "IVL_PQ" || field.type =='PQ'
-              value = field.format
-            end
-            
-            case name
-            when "ORDINAL"
-              entry.ordinality_code = codes
-            when "FACILITY_LOCATION"
-              entry.facility = Facility.new("name" => field.title, "codes" => codes)
-            when "CUMULATIVE_MEDICATION_DURATION"
-              entry.cumulative_medication_duration = value              
-            when "SEVERITY"
-              entry.severity = codes
-            when "REASON"
-              
-            when "SOURCE"
-
-            end
+
+        begin
+          field_accessor ||= HQMF::DataCriteria::FIELDS[name][:coded_entry_method]
+          entry.send("#{field_accessor}=", field_value)
+        rescue
+          # Give some feedback if we hit an unexpected error. Some fields have no action expected, so we'll suppress those messages.
+          noop_fields = ["LENGTH_OF_STAY", "START_DATETIME", "STOP_DATETIME"]
+          unless noop_fields.include? name
+            field_accessor = HQMF::DataCriteria::FIELDS[name][:coded_entry_method]
+            puts "Unknown field #{name} was unable to be added via #{field_accessor} to the patient" 
           end
         end
-         
-        # Figure out which section this entry will be added to. Some entry names don't map prettily to section names.
-        section_map = { "lab_results" => "results" }
-        section_name = section_map[entry_type]
-        section_name ||= entry_type
-        # Add the updated section to this patient.
-        section = patient.send(section_name)
-        section.push(entry)
-        
-        patient
       end
     end
+
+    # Add a coded entry to a patient.
+    #
+    # @param [Record] patient The coded entry that this data criteria is potentially negating.
+    # @param [Entry] entry The value sets that this data criteria references.
+    # @return The modified patient.
+    def modify_patient_with_entry(patient, entry)
+      return patient if entry.nil?
+
+      # Figure out which section this entry will be added to. Some entry names don't map prettily to section names.
+      entry_type = Generator.classify_entry(patient_api_function)
+      section_map = { "lab_results" => "results" }
+      section_name = section_map[entry_type]
+      section_name ||= entry_type
+
+      # Add the updated section to this patient.
+      section = patient.send(section_name)
+      section.push(entry)
+      
+      patient
+    end
+
+    def characteristic?
+      type == :characteristic && patient_api_function.nil? ? true : false
+    end
   end
 end

data/lib/tpg/ext/range.rb

@@ -1,144 +1,14 @@
 module HQMF
   class Range
-    # Perform a deep copy of this Range.
-    #
-    # @return A deep copy of this Range.
-    def clone
-      Range.new(type.try(:clone), low.try(:clone), high.try(:clone), width.try(:clone))
-    end
-    
+    # Form an HQMF Range object into a shape that HealthDataStandards understands.
     #
+    # @return A Range formatted for storing a HealthDataStandards Record.
     def format
       if low
         low.format
       elsif high
         high.format
-      else
-        {}
-      end
-    end
-    
-    # Perform an intersection between this Range and the passed in Range.
-    # There are three potential situations that can happen: disjoint, equivalent, or overlapping.
-    #
-    # @param [Range] range The other Range intersecting this. If it is nil it implies all times are ok (i.e. no restrictions).
-    # @return A new Range that represents the shared amount of time between these two Ranges. nil means there is no common time.
-    def intersection(range)
-      # Return self if nil (the other range has no restrictions) or if it matches the other range (they are equivalent)
-      return self.clone if range.nil?
-      return self.clone if eql?(range)
-
-      # Figure out which range starts later (the more restrictive one)
-      if low <= range.low
-        earlier_start = self
-        later_start = range
-      else
-        earlier_start = range
-        later_start = self
-      end
-      
-      # Return nil if there is no common time (the two ranges are entirely disjoint)
-      return nil unless later_start.contains?(earlier_start.high)
-      
-      # Figure out which ranges ends earlier (the more restrictive one)
-      if high >= range.high
-        earlier_end = self
-        later_end = range
-      else
-        earlier_end = range
-        later_end = self
-      end
-
-      Range.new("TS", later_start.low.clone, earlier_end.high.clone, nil)
-    end
-    
-    # Perform a union between this Range and the passed in Range.
-    # There are three potential situations that can happen: disjoint, equivalent, or overlapping.
-    #
-    # @param [Range] range The other Range unioning this.
-    # @return An array of Ranges. One element if the two ranges are overlapping and can be expressed as one new Range
-    #   or two Ranges if the times are disjoint.
-    def union(range)
-      # Return self if nil (nothing new to add) or if it matches the other range (they are equivalent)
-      return self.clone if range.nil?
-      return self.clone if eql?(range)
-
-      # Figure out which range starts earlier (to capture the most time)
-      if low <= range.low
-        earlier_start = self
-        later_start = range
-      else
-        earlier_start = range
-        later_start = self
-      end
-      
-      # Figure out which ranges ends earlier (the more restrictive one)
-      if high >= range.high
-        earlier_end = self
-        later_end = range
-      else
-        earlier_end = range
-        later_end = self
       end
-      
-      result = []
-      # We have continuous Ranges so we can return one Range to encapsulate both
-      if earlier_start.contains?(later_start.low)
-        result << Range.new("TS", earlier_start.low.clone, later_end.high.clone, nil)
-      else
-        # The Ranges are disjoint, so we'll need to return two arrays to capture all of the potential times
-        result << Range.new("TS", earlier_start.low.clone, earlier_start.high.clone, nil)
-        result << Range.new("TS", later_start.low.clone, later_start.high.clone, nil)
-      end
-    end
-    
-    # 
-    #
-    # @param [Range] ivl_pq
-    # @return
-    def apply_pq(ivl_pq)
-      
-    end
-    
-    # 
-    #
-    # @param [Range] range1 
-    # @param [Range] range2 
-    # @return 
-    def self.merge_ranges(range1, range2)
-      return nil if range1.nil? && range2.nil?
-      return range1 if range2.nil?
-      return range2 if range1.nil?
-      
-      type = range1.type == "PQ" && range2.type == "PQ" ? "IVL_PQ" : "IVL_TS"
-      low = Value.merge_values(range1.low, range2.low)
-      high = Value.merge_values(range1.high, range2.high)
-      width = nil
-      
-      Range.new(type, low, high, width)
-    end
-    
-    # Check to see if a given value falls within this Range's high and low.
-    #
-    # @param [Value] value The value that may or may not fall within the range.
-    # @return True if the value is contained. Otherwise, false.
-    def contains?(value)
-      start_time = low.to_time_object
-      end_time = high.to_time_object
-      time = value.to_time_object
-      
-      time.between?(start_time, end_time)
-    end
-    
-    # Check to see if a given Range's low and high matches this' low and high.
-    #
-    # @param [Range] range The Range to which we're comparing.
-    # @return True if the given range starts and ends at the same time as this. Otherwise, false.
-    def eql?(range)
-      return false if range.nil? || low.nil? || range.low.nil? || high.nil? || range.high.nil?
-      
-      return low.value == range.low.value && low.inclusive? == range.low.inclusive? &&
-             high.value == range.high.value && high.inclusive? == range.high.inclusive?
     end
   end
 end