davinci_us_drug_formulary_test_kit 0.9.0

data/lib/davinci_us_drug_formulary_test_kit/generator/ig_metadata_extractor.rb

@@ -0,0 +1,40 @@
+require_relative 'ig_metadata'
+require_relative 'group_metadata_extractor'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class IGMetadataExtractor
+      attr_accessor :ig_resources, :metadata
+
+      def initialize(ig_resources)
+        self.ig_resources = ig_resources
+        self.metadata = IGMetadata.new
+      end
+
+      def extract
+        add_metadata_from_ig
+        add_metadata_from_resources
+        metadata
+      end
+
+      def add_metadata_from_ig
+        metadata.ig_version = "v#{ig_resources.ig.version}"
+      end
+
+      def resources_in_capability_statement
+        ig_resources.capability_statement.rest.first.resource
+      end
+
+      def add_metadata_from_resources
+        metadata.groups =
+          resources_in_capability_statement.flat_map do |resource|
+            resource.supportedProfile&.map do |supported_profile|
+              GroupMetadataExtractor.new(resource, supported_profile, metadata, ig_resources).group_metadata
+            end
+          end.compact
+
+        # metadata.postprocess_groups(ig_resources)
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/ig_resources.rb

@@ -0,0 +1,60 @@
+require 'fhir_models'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class IGResources
+      def add(resource)
+        resources_by_type[resource.resourceType] << resource
+      end
+
+      def capability_statement(mode = 'server')
+        resources_by_type['CapabilityStatement'].find do |capability_statement_resource|
+          capability_statement_resource.rest.any? { |r| r.mode == mode }
+        end
+      end
+
+      def ig
+        resources_by_type['ImplementationGuide'].first
+      end
+
+      def inspect
+        'IGResources'
+      end
+
+      def profile_by_url(url)
+        resources_by_type['StructureDefinition'].find { |profile| profile.url == url }
+      end
+
+      def resource_for_profile(url)
+        resources_by_type['StructureDefinition'].find { |profile| profile.url == url }.type
+      end
+
+      def value_set_by_url(url)
+        resources_by_type['ValueSet'].find { |profile| profile.url == url }
+      end
+
+      def code_system_by_url(url)
+        resources_by_type['CodeSystem'].find { |system| system.url == url }
+      end
+
+      def search_param_by_resource_and_name(resource, name)
+        # remove '_' from search parameter name, such as _id or _tag
+        normalized_name = name.to_s.delete_prefix('_')
+
+        res = resources_by_type['SearchParameter']
+          .find { |param| param.id == "#{resource}-#{normalized_name}" }
+        if res.nil?
+          res = resources_by_type['SearchParameter']
+            .find { |param| param.id == "Resource-#{normalized_name}" }
+        end
+        res
+      end
+
+      private
+
+      def resources_by_type
+        @resources_by_type ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/include_search_test_generator.rb

@@ -0,0 +1,68 @@
+require_relative 'naming'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class IncludeSearchTestGenerator < SearchTestGenerator
+      INCLUDE_SEARCH_PARAMS = { 'Payer Insurance Plan' => 'coverage-type', 'Formulary Item' => 'code' }.freeze
+
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          # The IG defines the formulary-coverage include param for both InsuancePlan profiles,
+          # even though it only pertains to Payer Insurance Plan, so we explicitly exclude Formulary
+          ig_metadata.groups
+            .reject { |group| group.profile_name == 'Formulary' }
+            .reject { |group| group.include_params.empty? }
+            .each do |group|
+              group.include_params.each do |include_param|
+                search_meta = group.searches.find do |search|
+                  search[:names].include? INCLUDE_SEARCH_PARAMS[group.profile_name]
+                end
+                new(group, search_meta, base_output_dir, include_param).generate
+              end
+            end
+        end
+      end
+
+      attr_accessor :include_param
+
+      def initialize(group_metadata, search_metadata, base_output_dir, include_param)
+        super(group_metadata, search_metadata, base_output_dir)
+        self.include_param = include_param
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'include_search.rb.erb'))
+      end
+
+      def test_id
+        "usdf_#{group_metadata.reformatted_version}_#{profile_identifier}_#{search_identifier}_include_search_test"
+      end
+
+      def search_identifier
+        include_param.gsub(/[-:]/, '_').underscore
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title}IncludeSearchTest"
+      end
+
+      def search_properties
+        {}.tap do |properties|
+          properties[:resource_type] = "'#{resource_type}'"
+          properties[:search_param_names] = search_param_names
+          properties[:include_param] = "'#{include_param}'"
+        end
+      end
+
+      def include_param_string
+        "_include=#{include_param}"
+      end
+
+      def include_param_resource
+        res_type = group_metadata.search_definitions[:"#{include_param}"][:type]
+        res_type = group_metadata.search_definitions[:"#{include_param}"][:target] if res_type == 'Reference'
+        res_type
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/must_support_metadata_extractor.rb

@@ -0,0 +1,384 @@
+require_relative 'value_extractor'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class MustSupportMetadataExtractor
+      attr_accessor :profile_elements, :profile, :resource, :ig_resources
+
+      def initialize(profile_elements, profile, resource, ig_resources)
+        self.profile_elements = profile_elements
+        self.profile = profile
+        self.resource = resource
+        self.ig_resources = ig_resources
+      end
+
+      def must_supports
+        @must_supports = {
+          extensions: must_support_extensions,
+          slices: must_support_slices,
+          elements: must_support_elements,
+          references: must_support_references
+        }
+        # handle_special_cases
+
+        @must_supports
+      end
+
+      def all_must_support_elements
+        profile_elements.select(&:mustSupport)
+      end
+
+      def must_support_extension_elements
+        all_must_support_elements.select do |element|
+          (element.path.end_with? 'extension') && !element&.type&.first&.profile&.first.nil?
+        end
+      end
+
+      def must_support_extensions
+        # non_slice_extensions = must_support_extension_elements - slice_sub_elements
+        must_support_extension_elements.map do |element|
+          {
+            id: element.id,
+            url: element.type.first.profile.first,
+            path: element.path.gsub("#{resource}.", '')
+          }
+        end
+      end
+
+      def must_support_slice_elements
+        all_must_support_elements.select do |element|
+          !element.path.end_with?('extension') && element.sliceName.present?
+        end
+      end
+
+      # def slice_sub_elements
+      #   must_support_slice_elements.flat_map do |slice|
+      #     profile_elements.select do |element|
+      #       element.id != slice.id && element.id.start_with?(slice.id) && element.mustSupport
+      #     end
+      #   end
+      # end
+
+      def sliced_element(slice)
+        profile_elements.find do |element|
+          (element.id == slice.path && element.slicing.present?) || element.id == slice.id.sub(":#{slice.sliceName}",
+                                                                                               '')
+        end
+      end
+
+      def discriminators(slice)
+        slice.slicing.discriminator
+      end
+
+      def must_support_pattern_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'pattern'
+        end
+      end
+
+      def pattern_slices
+        must_support_pattern_slice_elements.map do |current_element|
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", '')
+          }.tap do |metadata|
+            discriminator = discriminators(sliced_element(current_element)).first
+            discriminator_path = discriminator.path
+            discriminator_path = '' if discriminator_path == '$this'
+            pattern_element =
+              if discriminator_path.present?
+                profile_elements.find { |element| element.id == "#{current_element.id}.#{discriminator_path}" }
+              else
+                current_element
+              end
+
+            metadata[:discriminator] =
+              if pattern_element.patternCodeableConcept.present?
+                {
+                  type: 'patternCodeableConcept',
+                  path: discriminator_path,
+                  code: pattern_element.patternCodeableConcept.coding.first.code,
+                  system: pattern_element.patternCodeableConcept.coding.first.system
+                }
+              elsif pattern_element.patternCoding.present?
+                {
+                  type: 'patternCoding',
+                  path: discriminator_path,
+                  code: pattern_element.patternCoding.code,
+                  system: pattern_element.patternCoding.system
+                }
+              elsif pattern_element.patternIdentifier.present?
+                {
+                  type: 'patternIdentifier',
+                  path: discriminator_path,
+                  system: pattern_element.patternIdentifier.system
+                }
+              elsif pattern_element.binding&.strength == 'required' &&
+                    pattern_element.binding&.valueSet.present?
+
+                value_extractor = ValueExactor.new(ig_resources, resource, profile_elements)
+
+                values = value_extractor.values_from_value_set_binding(pattern_element).presence ||
+                         value_extractor.values_from_resource_metadata([metadata[:path]]).presence || []
+
+                {
+                  type: 'requiredBinding',
+                  path: discriminator_path,
+                  values:
+                }
+              else
+                raise StandardError, 'Unsupported discriminator pattern type'
+              end
+          end
+        end
+      end
+
+      def must_support_type_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'type'
+        end
+      end
+
+      def type_slices
+        must_support_type_slice_elements.map do |current_element|
+          discriminator = discriminators(sliced_element(current_element)).first
+          type_path = discriminator.path
+          type_path = '' if type_path == '$this'
+          type_element =
+            if type_path.present?
+              elements.find { |element| element.id == "#{current_element.id}.#{type_path}" }
+            else
+              current_element
+            end
+
+          type_code = type_element.type.first.code
+
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", ''),
+            discriminator: {
+              type: 'type',
+              code: type_code.upcase_first
+            }
+          }
+        end
+      end
+
+      def must_support_value_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'value'
+        end
+      end
+
+      def value_slices
+        must_support_value_slice_elements.map do |current_element|
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", ''),
+            discriminator: {
+              type: 'value'
+            }
+          }.tap do |metadata|
+            metadata[:discriminator][:values] = discriminators(sliced_element(current_element)).map do |discriminator|
+              if discriminator.path == '$this'
+                fixed_element = profile_elements.find do |element|
+                  element.id.starts_with?(current_element.id) &&
+                    element.path == current_element.path.to_s
+                end
+                {
+                  path: fixed_element.path.gsub("#{resource}.", ''),
+                  value: fixed_element.binding.valueSet
+                }
+              else
+                fixed_element = profile_elements.find do |element|
+                  element.id.starts_with?(current_element.id) &&
+                    element.path == "#{current_element.path}.#{discriminator.path}"
+                end
+                {
+                  path: discriminator.path,
+                  value: fixed_element.fixedUri || fixed_element.fixedCode
+                }
+              end
+            end
+          end
+        end
+      end
+
+      def must_support_slices
+        pattern_slices + type_slices + value_slices
+      end
+
+      def plain_must_support_elements
+        all_must_support_elements - must_support_extension_elements - must_support_slice_elements
+      end
+
+      def element_part_of_slice_discrimination?(element)
+        must_support_slice_elements.any? { |ms_slice| element.id.include?(ms_slice.id) }
+      end
+
+      def handle_fixed_values(metadata, element)
+        if element.fixedUri.present?
+          metadata[:fixed_value] = element.fixedUri
+        elsif element.patternCodeableConcept.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternCodeableConcept.coding.first.code
+          metadata[:path] += '.coding.code'
+        elsif element.fixedCode.present?
+          metadata[:fixed_value] = element.fixedCode
+        elsif element.patternIdentifier.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternIdentifier.system
+          metadata[:path] += '.system'
+        end
+      end
+
+      def type_must_support_extension?(extensions)
+        extensions&.any? do |extension|
+          extension.url == 'http://hl7.org/fhir/StructureDefinition/elementdefinition-type-must-support' &&
+            extension.valueBoolean
+        end
+      end
+
+      def save_type_code?(type)
+        type.code == 'Reference'
+      end
+
+      def get_type_must_support_metadata(current_metadata, current_element)
+        current_element.type.map do |type|
+          next unless type_must_support_extension?(type.extension)
+
+          metadata =
+            {
+              path: "#{current_metadata[:path].delete_suffix('[x]')}#{type.code.upcase_first}",
+              original_path: current_metadata[:path]
+            }
+          metadata[:types] = [type.code] if save_type_code?(type)
+          handle_type_must_support_target_profiles(type, metadata) if type.code == 'Reference'
+
+          metadata
+        end.compact
+      end
+
+      def handle_type_must_support_target_profiles(type, metadata)
+        index = 0
+        target_profiles = []
+
+        type.source_hash['_targetProfile']&.each do |hash|
+          if hash.present?
+            element = FHIR::Element.new(hash)
+            target_profiles << type.targetProfile[index] if type_must_support_extension?(element.extension)
+          end
+          index += 1
+        end
+
+        metadata[:target_profiles] = target_profiles if target_profiles.present?
+      end
+
+      def handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+        choice_element_metadata = must_support_elements_metadata.find do |metadata|
+          metadata[:original_path].present? &&
+            current_metadata[:path].include?(metadata[:original_path])
+        end
+
+        return unless choice_element_metadata.present?
+
+        current_metadata[:original_path] = current_metadata[:path]
+        current_metadata[:path] =
+          current_metadata[:path].sub(choice_element_metadata[:original_path], choice_element_metadata[:path])
+      end
+
+      def must_support_elements
+        plain_must_support_elements.each_with_object([]) do |current_element, must_support_elements_metadata|
+          {
+            path: current_element.id.gsub("#{resource}.", '')
+          }.tap do |current_metadata|
+            type_must_support_metadata = get_type_must_support_metadata(current_metadata, current_element)
+
+            if type_must_support_metadata.any?
+              must_support_elements_metadata.concat(type_must_support_metadata)
+            else
+              handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+
+              supported_types = current_element.type.select { |type| save_type_code?(type) }.map(&:code)
+              current_metadata[:types] = supported_types if supported_types.present?
+
+              if current_element.type.first&.code == 'Reference'
+                handle_type_must_support_target_profiles(current_element.type.first,
+                                                         current_metadata)
+              end
+
+              handle_fixed_values(current_metadata, current_element)
+
+              must_support_elements_metadata.delete_if do |metadata|
+                metadata[:path] == current_metadata[:path] && metadata[:fixed_value].blank?
+              end
+
+              must_support_elements_metadata << current_metadata
+            end
+          end
+        end.uniq
+      end
+
+      def must_support_references
+        (must_support_reference_elements + must_support_reference_extensions)
+      end
+
+      def must_support_reference_elements
+        must_support_elements
+          .select { |element_definition| element_definition[:types]&.include?('Reference') }
+          .flat_map do |element_definition|
+            profile_element = profile_elements.find do |element|
+              element.path == "#{resource}.#{element_definition[:path]}"
+            end
+            (
+              element_definition[:target_profiles] ||
+              profile_element&.type&.first&.targetProfile ||
+              []
+            ).map do |target_profile|
+              {
+                path: element_definition[:path],
+                target_profile:
+              }
+            end
+          end
+      end
+
+      def must_support_reference_extensions
+        profile_elements
+          .select { |element| element.type.any? { |type| type.code == 'Extension' && type.profile.present? } }
+          .flat_map do |element|
+            extension_url = element.type.first.profile.first
+
+            next unless must_support_extensions.any? { |extension| extension[:url] == extension_url }
+
+            profiles =
+              ig_resources
+                .profile_by_url(extension_url)
+                &.snapshot
+                &.element
+                &.find { |profile_element| profile_element.id == 'Extension.value[x]:valueReference' }
+                &.type
+                &.first
+                &.targetProfile
+
+            next if profiles.blank?
+
+            path = element.path.delete_prefix("#{resource}.")
+
+            profiles.map do |target_profile|
+              {
+                path: "#{path}.where(url='#{extension_url}').valueReference",
+                target_profile:
+              }
+            end
+          end.compact
+      end
+
+      #### SPECIAL CASES ####
+
+      # def handle_special_cases
+      # end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/must_support_test_generator.rb

@@ -0,0 +1,117 @@
+require_relative 'naming'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class MustSupportTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+            .each { |group| new(group, base_output_dir).generate }
+        end
+      end
+
+      attr_accessor :group_metadata, :base_output_dir
+
+      def initialize(group_metadata, base_output_dir)
+        self.group_metadata = group_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'must_support.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def output_file_directory
+        File.join(base_output_dir, profile_identifier)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def read_interaction
+        self.class.read_interaction(group_metadata)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def test_id
+        "usdf_#{group_metadata.reformatted_version}_#{profile_identifier}_must_support_test"
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}MustSupportTest"
+      end
+
+      def module_name
+        "DaVinciUSDrugFormulary#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def resource_collection_string
+        'all_scratch_resources'
+      end
+
+      def must_support_list_string
+        build_must_support_list_string(false)
+      end
+
+      def uscdi_list_string
+        build_must_support_list_string(true)
+      end
+
+      def build_must_support_list_string(uscdi_only)
+        slice_names = group_metadata.must_supports[:slices]
+          .select { |slice| slice[:uscdi_only].presence == uscdi_only.presence }
+          .map { |slice| slice[:slice_id] }
+        element_names = group_metadata.must_supports[:elements]
+          .select { |element| element[:uscdi_only].presence == uscdi_only.presence }
+          .map { |element| "#{resource_type}.#{element[:path]}" }
+
+        extension_names = group_metadata.must_supports[:extensions]
+          .select { |extension| extension[:uscdi_only].presence == uscdi_only.presence }
+          .map { |extension| extension[:id] }
+
+        group_metadata.must_supports[:choices]&.each do |choice|
+          next unless choice[:uscdi_only].presence == uscdi_only.presence && choice.key?(:paths)
+
+          choice[:paths].each { |path| element_names.delete("#{resource_type}.#{path}") }
+          choice[:extension_ids].each { |id| extension_names.delete(id.to_s) } if choice[:extension_ids].present?
+
+          element_paths = choice[:paths].map { |path| "#{resource_type}.#{path}" }.join(' or ')
+          extension_ids = choice[:extension_ids].map(&:to_s).join(' or ')
+
+          element_names << ("#{element_paths} or #{extension_ids}")
+        end
+        (slice_names + element_names + extension_names)
+          .uniq
+          .sort
+          .map { |name| "#{' ' * 8}* #{name}" }
+          .join("\n")
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.write(output_file_name, output)
+
+        group_metadata.add_test(
+          id: test_id,
+          file_name: base_output_file_name
+        )
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/naming.rb

@@ -0,0 +1,28 @@
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    module Naming
+      class << self
+        def resources_with_multiple_profiles
+          ['InsurancePlan']
+        end
+
+        def resource_has_multiple_profiles?(resource)
+          resources_with_multiple_profiles.include? resource
+        end
+
+        def snake_case_for_profile(group_metadata)
+          resource = group_metadata.resource
+          return resource.underscore unless resource_has_multiple_profiles?(resource)
+
+          group_metadata.name
+            .delete_prefix('usdf_')
+            .underscore
+        end
+
+        def upper_camel_case_for_profile(group_metadata)
+          snake_case_for_profile(group_metadata).camelize
+        end
+      end
+    end
+  end
+end