inferno_core 0.2.0 → 0.3.0.rc1

data/lib/inferno/entities/input.rb

@@ -0,0 +1,121 @@
+require_relative 'attributes'
+require_relative '../exceptions'
+
+module Inferno
+  module Entities
+    # This class represents an Input for a runnable.
+    class Input
+      ATTRIBUTES = [
+        :name,
+        :title,
+        :description,
+        :type,
+        :default,
+        :optional,
+        :options,
+        :locked
+      ].freeze
+      include Entities::Attributes
+
+      # These attributes require special handling when merging input
+      # definitions.
+      UNINHERITABLE_ATTRIBUTES = [
+        # Locking an input only has meaning at the level it is locked.
+        # Consider:
+        # - ParentGroup
+        #   - Group 1, input :a
+        #   - Group 2, input :a, locked: true
+        # The input 'a' should be only be locked when running Group 2 in
+        # isolation. It should not be locked when running Group 1 or the
+        # ParentGroup.
+        :locked,
+        # Input type is sometimes only a UI concern (e.g. text vs. textarea), so
+        # it is common to not redeclare the type everywhere it's used and needs
+        # special handling to avoid clobbering the type with the default (text)
+        # type.
+        :type
+      ].freeze
+
+      # These are the attributes that can be directly copied when merging a
+      # runnable's input with the input of one of its children.
+      INHERITABLE_ATTRIBUTES = (ATTRIBUTES - UNINHERITABLE_ATTRIBUTES).freeze
+
+      # These are the attributes that can be directly copied when merging a
+      # runnable's input with an input configuration.
+      MERGEABLE_ATTRIBUTES = (ATTRIBUTES - [:type]).freeze
+
+      def initialize(**params)
+        bad_params = params.keys - ATTRIBUTES
+
+        raise Exceptions::UnknownAttributeException.new(bad_params, self.class) if bad_params.present?
+
+        params
+          .compact
+          .each { |key, value| send("#{key}=", value) }
+
+        self.name = name.to_s if params[:name].present?
+      end
+
+      # @private
+      # Merge this input with an input belonging to a child. Fields defined on
+      # this input take precedence over those defined on the child input.
+      def merge_with_child(child_input)
+        return self if child_input.nil?
+
+        INHERITABLE_ATTRIBUTES.each do |attribute|
+          merge_attribute(attribute, primary_source: self, secondary_source: child_input)
+        end
+
+        self.type = child_input.type if child_input.present? && child_input.type != 'text'
+
+        self
+      end
+
+      # @private
+      # Merge this input with an input from a configuration. Fields defined in
+      # the configuration take precedence over those defined on this input.
+      def merge(other_input)
+        return self if other_input.nil?
+
+        MERGEABLE_ATTRIBUTES.each do |attribute|
+          merge_attribute(attribute, primary_source: other_input, secondary_source: self)
+        end
+
+        self.type = other_input.type if other_input.type.present? && other_input.type != 'text'
+
+        self
+      end
+
+      # @private
+      # Merge an individual attribute. If the primary source contains the
+      # attribute, that value will be used. Otherwise the value from the
+      # secondary source will be used.
+      # @param attribute [Symbol]
+      # @param primary_source [Input]
+      # @param secondary_source [Input]
+      def merge_attribute(attribute, primary_source:, secondary_source:)
+        value = primary_source.send(attribute)
+        value = secondary_source.send(attribute) if value.nil?
+
+        return if value.nil?
+
+        send("#{attribute}=", value)
+      end
+
+      def to_hash
+        ATTRIBUTES.each_with_object({}) do |attribute, hash|
+          value = send(attribute)
+          next if value.nil?
+
+          hash[attribute] = value
+        end
+      end
+
+      def ==(other)
+        return false unless other.is_a? Input
+
+        ATTRIBUTES.all? { |attribute| send(attribute) == other.send(attribute) }
+      end
+    end
+  end
+end

data/lib/inferno/entities/test.rb

@@ -122,16 +122,16 @@ module Inferno
         #
         # @param name [Symbol] name of the input
         # @param other_names [Symbol] array of symbols if specifying multiple inputs
-        # @param input_definition [Hash] options for input such as type, description, or title
-        # @option input_definition [String] :title Human readable title for input
-        # @option input_definition [String] :description Description for the input
-        # @option input_definition [String] :type 'text' | 'textarea'
+        # @param input_params [Hash] options for input such as type, description, or title
+        # @option input_params [String] :title Human readable title for input
+        # @option input_params [String] :description Description for the input
+        # @option input_params [String] :type 'text' | 'textarea'
         # @return [void]
         # @example
         #   input :patientid, title: 'Patient ID', description: 'The ID of the patient being searched for'
         # @example
         #   input :textarea, title: 'Textarea Input Example', type: 'textarea'
-        def input(name, *other_names, **input_definition)
+        def input(name, *other_names, **input_params)
           super
 
           if other_names.present?

data/lib/inferno/ext/fhir_models.rb

@@ -0,0 +1,59 @@
+require 'json'
+
+# Extension to FHIR::Model. Prepending this into FHIR::Model (done below)
+# allows us to call super() on initialize when we overriding it,
+# while also defining new methods and attributes
+module InfernoFHIRModelExtensions
+  attr_accessor :source_hash, :source_text
+
+  def initialize(hash = {})
+    super(hash)
+    @source_hash = hash
+  end
+
+  def source_contents
+    @source_text || JSON.generate(@source_hash)
+  end
+end
+
+module FHIR
+  class Model
+    prepend ::InfernoFHIRModelExtensions
+  end
+end
+
+# Extension to FHIR::Json. Prepending this into FHIR::Json (done below)
+# allows us to call super() on from_json
+module InfernoJson
+  def from_json(json)
+    resource = super(json)
+    resource.source_text = json
+    resource
+  end
+end
+
+# Extension to FHIR::Xml. Prepending this into FHIR::Xml (done below)
+# allows us to call super() on from_xml
+module InfernoXml
+  def from_xml(xml)
+    resource = super(xml)
+    resource.source_text = xml
+    resource
+  end
+end
+
+module FHIR
+  module Json
+    class << self
+      prepend InfernoJson
+    end
+  end
+end
+
+module FHIR
+  module Xml
+    class << self
+      prepend InfernoXml
+    end
+  end
+end