fhir_models 1.6.3 → 1.6.4

data/lib/fhir/metadata.rb

@@ -1,26 +0,0 @@
-module FHIR
-
-  PRIMITIVES = {
-    'date' => {'type'=>'string', 'regex'=>'-?[0-9]{4}(-(0[1-9]|1[0-2])(-(0[0-9]|[1-2][0-9]|3[0-1]))?)?'},
-    'dateTime' => {'type'=>'string', 'regex'=>'-?[0-9]{4}(-(0[1-9]|1[0-2])(-(0[0-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?'},
-    'code' => {'type'=>'string', 'regex'=>'[^\\s]+([\\s]?[^\\s]+)*'},
-    'string' => {'type'=>'string'},
-    'integer' => {'type'=>'number', 'regex'=>'-?([0]|([1-9][0-9]*))'},
-    'oid' => {'type'=>'string', 'regex'=>'urn:oid:(0|[1-9][0-9]*)(\\.(0|[1-9][0-9]*))*'},
-    'uri' => {'type'=>'string'},
-    'uuid' => {'type'=>'string', 'regex'=>'urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'},
-    'instant' => {'type'=>'string'},
-    'boolean' => {'type'=>'true | false'},
-    'base64Binary' => {'type'=>'string'},
-    'unsignedInt' => {'type'=>'number', 'regex'=>'[0]|([1-9][0-9]*)'},
-    'markdown' => {'type'=>'string'},
-    'time' => {'type'=>'string', 'regex'=>'([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\\.[0-9]+)?'},
-    'id' => {'type'=>'string', 'regex'=>'[A-Za-z0-9\\-\\.]{1,64}'},
-    'positiveInt' => {'type'=>'number', 'regex'=>'[1-9][0-9]*'},
-    'decimal' => {'type'=>'number', 'regex'=>'-?([0]|([1-9][0-9]*))(\\.[0-9]+)?'},
-    'xhtml' => {'type'=>'string'}
-  }
-  TYPES = ["Reference", "Quantity", "Period", "Attachment", "Duration", "Count", "Range", "Annotation", "Money", "Identifier", "Coding", "Signature", "SampledData", "Ratio", "Distance", "Age", "CodeableConcept", "Extension", "BackboneElement", "Narrative", "Element", "Meta", "RelatedResource", "Address", "TriggerDefinition", "Contributor", "DataRequirement", "ContactDetail", "HumanName", "ContactPoint", "UsageContext", "Timing", "ElementDefinition", "ParameterDefinition"]
-  RESOURCES = ["CodeSystem", "ValueSet", "DomainResource", "Parameters", "Resource", "Account", "ActivityDefinition", "AllergyIntolerance", "Appointment", "AppointmentResponse", "AuditEvent", "Basic", "Binary", "BodySite", "Bundle", "CarePlan", "CareTeam", "Claim", "ClaimResponse", "ClinicalImpression", "Communication", "CommunicationRequest", "CompartmentDefinition", "Composition", "ConceptMap", "Condition", "Conformance", "Consent", "Contract", "Coverage", "DataElement", "DecisionSupportServiceModule", "DetectedIssue", "Device", "DeviceComponent", "DeviceMetric", "DeviceUseRequest", "DeviceUseStatement", "DiagnosticReport", "DiagnosticRequest", "DocumentManifest", "DocumentReference", "EligibilityRequest", "EligibilityResponse", "Encounter", "Endpoint", "EnrollmentRequest", "EnrollmentResponse", "EpisodeOfCare", "ExpansionProfile", "ExplanationOfBenefit", "FamilyMemberHistory", "Flag", "Goal", "Group", "GuidanceResponse", "HealthcareService", "ImagingManifest", "ImagingStudy", "Immunization", "ImmunizationRecommendation", "ImplementationGuide", "Library", "Linkage", "List", "Location", "Measure", "MeasureReport", "Media", "Medication", "MedicationAdministration", "MedicationDispense", "MedicationOrder", "MedicationStatement", "MessageHeader", "NamingSystem", "NutritionRequest", "Observation", "OperationDefinition", "OperationOutcome", "Organization", "Patient", "PaymentNotice", "PaymentReconciliation", "Person", "PlanDefinition", "Practitioner", "PractitionerRole", "Procedure", "ProcedureRequest", "ProcessRequest", "ProcessResponse", "Provenance", "Questionnaire", "QuestionnaireResponse", "ReferralRequest", "RelatedPerson", "RiskAssessment", "Schedule", "SearchParameter", "Sequence", "Slot", "Specimen", "StructureDefinition", "StructureMap", "Subscription", "Substance", "SupplyDelivery", "SupplyRequest", "Task", "TestScript", "VisionPrescription"]
-
-end

data/test/test_helper.rb

@@ -1,10 +0,0 @@
-require 'simplecov'
-require_relative '../lib/fhir_models'
-
-require 'fileutils'
-require 'pry'
-require 'nokogiri/diff'
-require 'minitest/autorun'
-require 'bundler/setup'
-require 'test/unit'
-require 'turn'

data/test/unit/contents_test.rb

@@ -1,35 +0,0 @@
-require_relative '../test_helper'
-
-class ContentsTest < Test::Unit::TestCase
-
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  EXAMPLE_JSON = File.join('examples','json','patient-example.json')
-  EXAMPLE_XML  = File.join('examples','xml','patient-example.xml')
-
-  def test_xml_from_contents
-    xml = File.read(EXAMPLE_XML)
-    patient = FHIR.from_contents(xml)
-    assert !patient.nil?, "From contents did not succeed with XML."
-    assert patient.id=='example', "Patient did not deserialize correctly."
-  end
-
-  def test_json_from_contents
-    json = File.read(EXAMPLE_JSON)
-    patient = FHIR.from_contents(json)
-    assert !patient.nil?, "From contents did not succeed with JSON."
-    assert patient.id=='example', "Patient did not deserialize correctly."
-  end
-
-  def test_negative_json_contents
-    nothing = FHIR.from_contents('{}')
-    assert nothing.nil?, "From contents should have returned nil."
-  end
-
-  def test_negative_xml_contents
-    nothing = FHIR.from_contents('<?xml version="1.0" encoding="UTF-8"?><Nothing/>')
-    assert nothing.nil?, "From contents should have returned nil."
-  end
-
-end

data/test/unit/equality_test.rb

@@ -1,79 +0,0 @@
-require_relative '../test_helper'
-
-class EqualityTest < Test::Unit::TestCase
- 
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  EXAMPLE_ROOT = File.join('examples')
-  ERROR_DIR = File.join('errors', 'EqualityTest')
-
-  # Create a blank folder for the errors
-  FileUtils.rm_rf(ERROR_DIR) if File.directory?(ERROR_DIR)
-  FileUtils.mkdir_p ERROR_DIR
-
-  # Automatically generate one test method per example file
-  example_json_files = File.join(EXAMPLE_ROOT, '**', '*.json')
-  example_xml_files = File.join(EXAMPLE_ROOT, '**', '*.xml')
-
-  Dir.glob(example_json_files).each do | example_file |
-    example_name = File.basename(example_file, ".json")
-    define_method("test_equality_#{example_name}_json") do
-      run_json_equality_test(example_file, example_name)
-    end
-  end
-
-  Dir.glob(example_xml_files).each do | example_file |
-    example_name = File.basename(example_file, ".xml")
-    define_method("test_equality_#{example_name}_xml") do
-      run_xml_equality_test(example_file, example_name)
-    end
-  end
-
-  Dir.glob(example_json_files).each do | example_json_file |
-    example_name = File.basename(example_json_file, ".json")
-    example_xml_file = File.join(EXAMPLE_ROOT,'xml',"#{example_name}.xml")
-    define_method("test_equality_#{example_name}") do
-      run_equality_test(example_json_file, example_xml_file, example_name)
-    end
-  end
-
-  def run_json_equality_test(example_file, example_name)
-    input_json = File.read(example_file)
-    instanceA = FHIR::Json.from_json(input_json)
-    instanceB = FHIR::Json.from_json(input_json)
-    if(!instanceA.equals?(instanceB) || !instanceB.equals?(instanceA))
-      File.open("#{ERROR_DIR}/#{example_name}.json", 'w:UTF-8') {|file| file.write(input_json)}
-    end
-    assert instanceA.equals?(instanceB), "Instance A should be equal to instance B."
-    assert instanceB.equals?(instanceA), "Instance B should be equal to instance A."
-  end
-
-  def run_xml_equality_test(example_file, example_name)
-    input_xml = File.read(example_file)
-    instanceA = FHIR::Xml.from_xml(input_xml)
-    instanceB = FHIR::Xml.from_xml(input_xml)
-    if(!instanceA.equals?(instanceB) || !instanceB.equals?(instanceA))
-      File.open("#{ERROR_DIR}/#{example_name}.xml", 'w:UTF-8') {|file| file.write(input_xml)}
-    end
-    assert instanceA.equals?(instanceB), "Instance A should be equal to instance B."
-    assert instanceB.equals?(instanceA), "Instance B should be equal to instance A."
-  end
-
-  def run_equality_test(example_json_file, example_xml_file, example_name)
-    input_json = File.read(example_json_file)
-    input_xml = File.read(example_xml_file)
-    instanceA = FHIR::Json.from_json(input_json)
-    instanceB = FHIR::Xml.from_xml(input_xml)
-    exclude = ['div']
-    if(!instanceA.equals?(instanceB,exclude) || !instanceB.equals?(instanceA,exclude))
-      File.open("#{ERROR_DIR}/#{example_name}_A.json", 'w:UTF-8') {|file| file.write(instanceA.to_json)}
-      File.open("#{ERROR_DIR}/#{example_name}_B.json", 'w:UTF-8') {|file| file.write(instanceB.to_json)}
-      File.open("#{ERROR_DIR}/#{example_name}_A.xml", 'w:UTF-8') {|file| file.write(instanceA.to_xml)}
-      File.open("#{ERROR_DIR}/#{example_name}_B.xml", 'w:UTF-8') {|file| file.write(instanceB.to_xml)}
-    end
-    assert instanceA.equals?(instanceB,exclude), "Instance A should be equal to instance B."
-    assert instanceB.equals?(instanceA,exclude), "Instance B should be equal to instance A."
-  end  
-
-end

data/test/unit/expansions_test.rb

@@ -1,18 +0,0 @@
-require_relative '../test_helper'
-
-class ExpansionsTest < Test::Unit::TestCase
-
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  def test_expansion
-    codes = FHIR::Definitions.get_codes('http://hl7.org/fhir/ValueSet/relatedperson-relationshiptype')
-    assert (!codes.nil? && !codes.empty?), "Expansions did not return expected codes."
-  end
-
-  def test_missing_expansion
-    codes = FHIR::Definitions.get_codes('http://projectcrucible.org/nonexisting/valueset')
-    assert (codes.nil? || codes.empty?), "Expansions returned unexpected codes."
-  end
-
-end

data/test/unit/extension_by_name_test.rb

@@ -1,45 +0,0 @@
-require_relative '../test_helper'
-
-class ExtensionByNameTest < Test::Unit::TestCase
-
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  def test_extension_by_name
-    patient = FHIR::Patient.new
-    patient.extension << FHIR::Extension.new({url: 'http://projectcrucible.org/extensions/foobar', valueInteger: 42})
-    assert ( patient.foobar == 42), "Method missing did not correctly find the extension value."
-  end
-
-  def test_modifier_extension_by_name
-    patient = FHIR::Patient.new
-    patient.modifierExtension << FHIR::Extension.new({url: 'http://projectcrucible.org/extensions/foobar', valueInteger: 42})
-    assert ( patient.foobar == 42), "Method missing did not correctly find the extension value."
-  end
-
-  def test_extension_by_anchor
-    patient = FHIR::Patient.new
-    patient.extension << FHIR::Extension.new({url: 'http://projectcrucible.org/extensions/foo#bar', valueInteger: 42})
-    assert ( patient.bar == 42), "Method missing did not correctly find the extension value."
-  end
-
-  def test_modifier_extension_by_anchor
-    patient = FHIR::Patient.new
-    patient.modifierExtension << FHIR::Extension.new({url: 'http://projectcrucible.org/extensions/foo#bar', valueInteger: 42})
-    assert ( patient.bar == 42), "Method missing did not correctly find the modifier extension value."
-  end
-
-  def test_nested_extension_by_name
-    patient = FHIR::Patient.new
-    patient.extension << FHIR::Extension.new({url: 'http://projectcrucible.org/extensions/foo'})
-    patient.extension.first.extension << FHIR::Extension.new({url: '#bar', valueInteger: 42})
-    assert ( patient.foo.bar == 42), "Method missing did not correctly find the extension value."
-  end
-
-  def test_nested_modifier_extension_by_name
-    patient = FHIR::Patient.new
-    patient.modifierExtension << FHIR::Extension.new({url: 'http://projectcrucible.org/extensions/foo'})
-    patient.modifierExtension.first.extension << FHIR::Extension.new({url: '#bar', valueInteger: 42})
-    assert ( patient.foo.bar == 42), "Method missing did not correctly find the modifier extension value."
-  end
-end

data/test/unit/fluentpath/and_or_not_test.rb

@@ -1,69 +0,0 @@
-require_relative '../../test_helper'
-
-class AndOrNotTest < Test::Unit::TestCase
-
-  def test_and_or_not
-    data = {
-      'name' => {
-        'given' => [ 'Joe', 'John' ]
-      },
-      'gender' => 'male',
-      'deceased' => false
-    }
-    result = FluentPath.evaluate('deceased.not() and ((name.given or name.family) and gender) and deceased.not()',data)
-    assert result==true, 'Failed and_or_not test.'
-  end
-
-  def test_xor_tt
-    data = {
-      'a' => true,
-      'b' => true
-    }
-    result = FluentPath.evaluate('a xor b',data)
-    assert result==false, 'Failed xor test.'    
-  end
-
-  def test_xor_tf
-    data = {
-      'a' => true,
-      'b' => false
-    }
-    result = FluentPath.evaluate('a xor b',data)
-    assert result==true, 'Failed xor test.'    
-  end
-
-  def test_xor_ft
-    data = {
-      'a' => false,
-      'b' => true
-    }
-    result = FluentPath.evaluate('a xor b',data)
-    assert result==true, 'Failed xor test.'    
-  end
-
-  def test_xor_ff
-    data = {
-      'a' => false,
-      'b' => false
-    }
-    result = FluentPath.evaluate('a xor b',data)
-    assert result==false, 'Failed xor test.'    
-  end
-
-  def test_xor_tnil
-    data = {
-      'a' => true
-    }
-    result = FluentPath.evaluate('a xor b',data)
-    assert result==true, 'Failed xor test.'    
-  end
-
-  def test_xor_nilstring
-    data = {
-      'b' => 'foo'
-    }
-    result = FluentPath.evaluate('a xor b',data)
-    assert result==true, 'Failed xor test.'    
-  end  
-
-end

data/test/unit/fluentpath/convert_to_boolean_test.rb

@@ -1,59 +0,0 @@
-require_relative '../../test_helper'
-
-class ConvertToBooleanTest < Test::Unit::TestCase
-
-  def test_true_is_true
-    data = true
-    result = FluentPath.convertToBoolean(data)
-    assert result==true, 'true should be converted to true.'
-  end
-
-  def test_false_is_false
-    data = false
-    result = FluentPath.convertToBoolean(data)
-    assert result==false, 'false should be converted to false.'
-  end
-
-  def test_nil_is_false
-    data = nil
-    result = FluentPath.convertToBoolean(data)
-    assert result==false, 'nil should be converted to false.'
-  end
-
-  def test_empty_hash_is_false
-    data = {}
-    result = FluentPath.convertToBoolean(data)
-    assert result==false, 'An empty hash should be converted to false.'
-  end
-
-  def test_empty_array_is_false
-    data = []
-    result = FluentPath.convertToBoolean(data)
-    assert result==false, 'An empty array should be converted to false.'
-  end
-
-  def test_array_with_contents_is_true
-    data = [false,true,false]
-    result = FluentPath.convertToBoolean(data)
-    assert result==true, 'An array with contents should be converted to true.'
-  end
-
-  def test_hash_with_contents_is_true
-    data = {'foo'=>'bar'}
-    result = FluentPath.convertToBoolean(data)
-    assert result==true, 'A hash with contents should be converted to true.'
-  end
-
-  def test_string_is_true
-    data = 'foo'
-    result = FluentPath.convertToBoolean(data)
-    assert result==true, 'A string should be converted to true.'
-  end
-
-  def test_empty_string_is_true
-    data = ''
-    result = FluentPath.convertToBoolean(data)
-    assert result==true, 'An empty string should be converted to true.'
-  end
-
-end

data/test/unit/fluentpath/existence_test.rb

@@ -1,154 +0,0 @@
-require_relative '../../test_helper'
-
-class ExistenceTest < Test::Unit::TestCase
-
-  NAMES = ['Bob','Robert']
-  PATIENT = {
-    'name' => {
-      'given' => NAMES
-    },
-    'deceasedBoolean' => false,
-    'aliveBoolean' => true,
-    'all_true' => [true,true,true],
-    'some_true' => [false,true,false],
-    'codes' => ['A','A','B'],
-    'numbers' => [0.1,0.1,1,-2],
-    'resourceType' => 'Patient'
-  }
-
-  # ------------------------- empty() -------------------------------------
-  def test_empty_false
-    result = FluentPath.evaluate('Patient.name.given.empty()',PATIENT)
-    assert result==false, 'Failed empty test.'
-  end
-
-  def test_empty_true
-    result = FluentPath.evaluate('Patient.name.family.empty()',PATIENT)
-    assert result==true, 'Failed empty test.'
-  end
-
-  # ------------------------- not() -------------------------------------
-  def test_not_true
-    result = FluentPath.evaluate('Patient.deceasedBoolean.not()',PATIENT)
-    assert result==true, 'Failed not test.'
-  end
-
-  def test_not_false
-    result = FluentPath.evaluate('Patient.aliveBoolean.not()',PATIENT)
-    assert result==false, 'Failed not test.'
-  end
-
-  def test_not_empty
-    result = FluentPath.evaluate('Patient.doesNotExist.not()',PATIENT)
-    assert result==true, 'Failed not test.'
-  end
-  def test_not_notempty
-    result = FluentPath.evaluate('Patient.name.given.not()',PATIENT)
-    assert result==false, 'Failed not test.'
-  end
-
-  # ------------------------- exists() -------------------------------------
-  def test_exists_true
-    result = FluentPath.evaluate('Patient.name.given.exists()',PATIENT)
-    assert result==true, 'Failed exists test.'
-  end
-
-  def test_exists_false
-    result = FluentPath.evaluate('Patient.name.family.exists()',PATIENT)
-    assert result==false, 'Failed exists test.'
-  end
-
-  # ------------------------- all() -------------------------------------
-  def test_all_true
-    result = FluentPath.evaluate('Patient.all_true.all()',PATIENT)
-    assert result==true, 'Failed all test.'
-  end
-
-  def test_all_false
-    result = FluentPath.evaluate('Patient.some_true.all()',PATIENT)
-    assert result==false, 'Failed all test.'
-  end
-  
-  # ------------------------- subsetOf([]) -------------------------------------
-  # ------------------------- supersetOf([]) -------------------------------------
-  # ------------------------- isDistinct() -------------------------------------
-  # ------------------------- distinct() -------------------------------------
-  def test_distinct_strings
-    result = FluentPath.evaluate('Patient.codes.distinct()',PATIENT)
-    assert result==['A','B'], 'Failed distinct test.'
-  end
-
-  def test_distinct_numbers
-    result = FluentPath.evaluate('Patient.numbers.distinct()',PATIENT)
-    assert result==[0.1,1,-2], 'Failed distinct test.'
-  end  
-
-  def test_distinct_booleans
-    result = FluentPath.evaluate('Patient.some_true.distinct()',PATIENT)
-    assert result==[false,true], 'Failed distinct test.'
-  end
-
-  # ------------------------- count() -------------------------------------
-  # ------------------------- in -------------------------------------
-  def test_in_numbers
-    data = {
-      'foo' => 2,
-      'set' => [1,2,3]
-    }
-    result = FluentPath.evaluate('foo in set',data)
-    assert result==true, 'Failed in_numbers test.'
-  end
-
-  def test_in_strings
-    data = {
-      'foo' => 'B',
-      'set' => ['A','B','C']
-    }
-    result = FluentPath.evaluate('foo in set',data)
-    assert result==true, 'Failed in_strings test.'
-  end
-
-  def test_in_booleans
-    data = {
-      'foo' => true,
-      'set' => [false,true,false]
-    }
-    result = FluentPath.evaluate('foo in set',data)
-    assert result==true, 'Failed in_booleans test.'
-  end
-
-  def test_in_numbers_false
-    data = {
-      'foo' => 5,
-      'set' => [1,2,3]
-    }
-    result = FluentPath.evaluate('foo in set',data)
-    assert result==false, 'Failed in_numbers_false test.'
-  end
-
-  def test_in_strings_false
-    data = {
-      'foo' => 'D',
-      'set' => ['A','B','C']
-    }
-    result = FluentPath.evaluate('foo in set',data)
-    assert result==false, 'Failed in_strings_false test.'
-  end
-
-  def test_in_booleans_false
-    data = {
-      'foo' => true,
-      'set' => [false,false]
-    }
-    result = FluentPath.evaluate('foo in set',data)
-    assert result==false, 'Failed in_booleans_false test.'
-  end
-
-  # ------------------- set creation ------------------------
-  def test_set_creation
-    data = {}
-    result = FluentPath.evaluate("('A'|'B'|'C')",data)
-    assert result==['A','B','C'], 'Failed set creation.'
-  end
-
-end