FI-3376 Migrate Evaluator CLI into inferno core CLI

lib/inferno/apps/cli/evaluate.rb

@@ -0,0 +1,64 @@
+require_relative '../../../inferno/dsl/fhir_evaluation/evaluator'
+
+module Inferno
+  module CLI
+    class Evaluate
+      def run(ig_path, data_path, _log_level)
+        validate_args(ig_path, data_path)
+
+        # IG Import, rule execution, and result output below will be integrated at phase 2 and 3.
+
+        # @ig = File.join(__dir__, 'ig', ig_path)
+        # if data_path
+        #   DatasetLoader.from_path(File.join(__dir__, data_path))
+        # else
+        #   ig.examples
+        # end
+
+        # config = Config.new
+        # evaluator = Inferno::DSL::FHIREvaluation::Evaluator.new(data, config)
+
+        # results = evaluate()
+        # output_results(results, options[:output])
+      end
+
+      def validate_args(ig_path, data_path)
+        raise 'A path to an IG is required!' unless ig_path
+
+        return unless data_path && (!File.directory? data_path)
+
+        raise "Provided path '#{data_path}' is not a directory"
+      end
+
+      def output_results(results, output)
+        if output&.end_with?('json')
+          oo = FhirEvaluator::EvaluationResult.to_operation_outcome(results)
+          File.write(output, oo.to_json)
+          puts "Results written to #{output}"
+        else
+          counts = results.group_by(&:severity).transform_values(&:count)
+          print(counts, 'Result Count')
+          puts "\n"
+          puts results
+        end
+      end
+
+      def print(output_fields, title)
+        puts("╔══════════════ #{title} ═══════════════╗")
+        puts('║ ╭────────────────┬──────────────────────╮ ║')
+        output_fields.each_with_index do |(key, value), i|
+          field_name = pad(key, 14)
+          field_value = pad(value.to_s, 20)
+          puts("║ │ #{field_name} │ #{field_value} │ ║")
+          puts('║ ├────────────────┼──────────────────────┤ ║') unless i == output_fields.length - 1
+        end
+        puts('║ ╰────────────────┴──────────────────────╯ ║')
+        puts('╚═══════════════════════════════════════════╝')
+      end
+
+      def pad(string, length)
+        format("%#{length}.#{length}s", string)
+      end
+    end
+  end
+end

lib/inferno/apps/cli/main.rb

@@ -1,4 +1,5 @@
 require_relative 'console'
+require_relative 'evaluate'
 require_relative 'migration'
 require_relative 'services'
 require_relative 'suite'
@@ -10,6 +11,43 @@
 module Inferno
   module CLI
     class Main < Thor
+      desc 'evaluate', 'Run a FHIR Data Evaluator.'
+      long_desc <<-LONGDESC
+        Evaluate FHIR data in the context of a given Implementation Guide,
+        by applying a set of predefined rules designed to check that datasets are comprehensive.
+        Issues identified will be printed to console or to a json file.
+
+        You must have background services running: `bundle exec inferno services start`
+
+        Run the evaluation CLI with
+
+        `bundle exec inferno evaluate ig_path`
+
+        Examples:
+
+        # Load the us core ig and evaluate the data in the provided example folder. If there are examples in the IG already, they will be ignored.
+        `bundle exec inferno evaluate ./uscore.tgz -d ./package/example`
+
+        # Loads the us core ig and evaluate the data included in the IG's example folder
+        `bundle exec inferno evaluate ./uscore.tgz`
+
+        # Loads the us core ig and evaluate the data included in the IG's example folder, with results redirected to outcome.json as an OperationOutcome
+        `bundle exec inferno evaluate ./uscore.tgz --output outcome.json`
+      LONGDESC
+      # TODO: Add options below as arguments
+      option :data_path,
+             aliases: ['-d'],
+             type: :string,
+             desc: 'Example FHIR data path'
+      # TODO: implement option of exporting result as OperationOutcome
+      option :output,
+             aliases: ['-o'],
+             type: :string,
+             desc: 'Export evaluation result to outcome.json as an OperationOutcome'
+      def evaluate(ig_path)
+        Evaluate.new.run(ig_path, options[:data_path], Logger::INFO)
+      end
+
       desc 'console', 'Start an interactive console session with Inferno'
       def console
         Migration.new.run(Logger::INFO)

lib/inferno/dsl.rb

@@ -1,6 +1,7 @@
 require_relative 'dsl/assertions'
 require_relative 'dsl/fhir_client'
 require_relative 'dsl/fhir_validation'
+require_relative 'dsl/fhir_evaluation/evaluator'
 require_relative 'dsl/fhir_resource_validation'
 require_relative 'dsl/fhirpath_evaluation'
 require_relative 'dsl/http_client'
@@ -18,6 +19,7 @@ module DSL
       HTTPClient,
       Results,
       FHIRValidation,
+      FHIREvaluation,
       FHIRResourceValidation,
       FhirpathEvaluation,
       Messages

lib/inferno/dsl/fhir_evaluation/config.rb

@@ -0,0 +1,21 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      class Config
+        DEFAULT_FILE = File.join(__dir__, 'default.yml')
+        attr_accessor :data
+
+        # To-do: add config_file as arguments
+        def initialize(config_file = nil)
+          @data = if config_file.nil?
+                    YAML.load_file(File.absolute_path(DEFAULT_FILE))
+                  else
+                    YAML.load_file(File.absolute_path(config_file))
+                  end
+
+          raise(TypeError, 'Malformed configuration') unless @data.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

lib/inferno/dsl/fhir_evaluation/dataset_loader.rb

@@ -0,0 +1,33 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module DatasetLoader
+        def self.from_contents(source_array)
+          dataset = []
+
+          source_array.each do |json|
+            resource = FHIR::Json.from_json(json)
+            next if resource.nil?
+
+            dataset.push resource
+          end
+
+          dataset
+        end
+
+        def self.from_path(path)
+          dataset = []
+
+          Dir["#{path}/*.json"].each do |f|
+            resource = FHIR::Json.from_json(File.read(f))
+            next if resource.nil?
+
+            dataset.push resource
+          end
+
+          dataset
+        end
+      end
+    end
+  end
+end

lib/inferno/dsl/fhir_evaluation/default.yml

@@ -0,0 +1,9 @@
+Environment:
+  ExternalValidator: 
+    Enabled: false
+    Url: ''
+  VSAC:
+    Apikey: ''
+    Url: 'https://cts.nlm.nih.gov'
+
+Rule:

lib/inferno/dsl/fhir_evaluation/evaluation_context.rb

@@ -0,0 +1,27 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      # EvaluationContext is a wrapper class around the concepts needed to perform an evaluation:
+      # - The IG used as the basis for evaluation
+      # - The data being evaluated
+      # - A summary/characterization of the data
+      # - Evaluation results
+      class EvaluationContext
+        attr_reader :ig, :data, :results, :config
+
+        # rubocop:disable Naming/MethodParameterName
+        def initialize(ig, data, config)
+          @ig = ig
+          @data = data
+          @results = []
+          @config = config
+        end
+        # rubocop:enable Naming/MethodParameterName
+
+        def add_result(result)
+          results.push result
+        end
+      end
+    end
+  end
+end

lib/inferno/dsl/fhir_evaluation/evaluation_result.rb

@@ -0,0 +1,62 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      # The result of a Rule evaluating a data set.
+      class EvaluationResult
+        attr_accessor :message,
+                      :severity,   # fatal | error | warning | information | success
+                      :issue_type, # https://www.hl7.org/fhir/valueset-issue-type.html
+                      :threshold,  # quantitative value that a rule checks for
+                      :value,      # actual observed value
+                      :rule        # Rule that produced this result
+
+        def initialize(message, severity: 'warning', issue_type: 'business-rule', threshold: nil, value: nil, rule: nil)
+          @message = message
+          @severity = severity
+          @issue_type = issue_type
+          @threshold = threshold
+          @value = value
+          @rule = rule
+        end
+
+        def to_s
+          "#{severity.upcase}: #{message}"
+        end
+
+        def to_oo_issue
+          issue = {
+            severity:,
+            code: issue_type,
+            details: { text: message }
+          }
+
+          if threshold
+            issue[:extension] ||= []
+            issue[:extension].push({
+                                     # TODO: pick real extension for this
+                                     url: 'https://inferno-framework.github.io/fhir_evaluator/StructureDefinition/operationoutcome-issue-threshold',
+                                     valueDecimal: threshold
+                                   })
+          end
+
+          if value
+            issue[:extension] ||= []
+            issue[:extension].push({
+                                     # TODO: pick real extension for this
+                                     url: 'https://inferno-framework.github.io/fhir_evaluator/StructureDefinition/operationoutcome-issue-value',
+                                     valueDecimal: value
+                                   })
+          end
+
+          issue
+        end
+
+        def self.to_operation_outcome(results)
+          FHIR::OperationOutcome.new({
+                                       issue: results.map(&:to_oo_issue)
+                                     })
+        end
+      end
+    end
+  end
+end

lib/inferno/dsl/fhir_evaluation/evaluator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'config'
+require_relative 'rule'
+require_relative 'evaluation_context'
+require_relative 'evaluation_result'
+require_relative 'dataset_loader'
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      class Evaluator
+        attr_accessor :ig
+
+        # rubocop:disable Naming/MethodParameterName
+        def initialize(ig)
+          @ig = ig
+        end
+        # rubocop:enable Naming/MethodParameterName
+
+        def evaluate(data, config = Config.new)
+          context = EvaluationContext.new(@ig, data, config)
+
+          active_rules = []
+          config.data['Rule'].each do |rulename, rule_details|
+            active_rules << rulename if rule_details['Enabled']
+          end
+
+          Rule.descendants.each do |rule|
+            rule.new.check(context) if active_rules.include?(rule.name.demodulize)
+          end
+
+          context.results
+        end
+      end
+    end
+  end
+end

lib/inferno/dsl/fhir_evaluation/rule.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      class Rule
+        def check(_context)
+          raise 'not implemented'
+        end
+      end
+    end
+  end
+end