knartform 0.6.0

data/bin/spot_check

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'pp'
+require 'byebug'
+require 'nokogiri'
+require 'slim'
+
+require_relative "../lib/common"
+include Repository
+
+HELP = <<EOF
+
+Renders a number of validation metrics for every KNART XML document references in a provided manifest.json.
+
+	USAGE: #{__FILE__} <manifest.json> <output.html>
+
+	EXAMPLE:
+		#{__FILE__} manifest.json output.html
+
+EOF
+
+def report(good, bad)
+	puts "\nGood file references: #{good.length}"
+	puts "Bad file references: #{bad.length}"
+	bad.each do |n| puts "\t#{[n['path'],n['url']].join(' ')}" end
+	puts "\n"
+end
+
+def extract_metadata(doc)
+	return {
+		identifiers: doc.xpath("///xmlns:metadata/xmlns:identifiers/xmlns:identifier/@identifierName").count, #collect{|n| n.to_s},
+		relatedResources: doc.xpath("//xmlns:relatedResource//xmlns:resource").count,
+		supportingEvidence: doc.xpath("//xmlns:supportingEvidence//xmlns:resource").count,
+		applicability: doc.xpath("//xmlns:applicability/xmlns:coverage").count,
+		eventHistory: doc.xpath("//xmlns:eventHistory/xmlns:artifactLifeCycleEvent").count,
+		contributions: doc.xpath("//xmlns:contributions//xmlns:contributor").count,
+		publishers: doc.xpath("//xmlns:publishers//xmlns:publisher").count,
+	}
+end
+
+def knart_validations(doc)
+	# We'll cover the basics first.
+	report = {
+		doc: doc,
+		title: doc.xpath("//xmlns:title/@value").first.to_s,
+		artifactType: doc.xpath("//xmlns:artifactType/@value").first.to_s,
+		metadata: extract_metadata(doc)
+	}
+	# Global ELM stuff.
+	exps = doc.xpath("/xmlns:knowledgeDocument/xmlns:expressions/xmlns:def")
+	
+	report[:expressions] = exps.collect{|e| {
+		name: e.xpath("@name").to_s,
+		type: e.xpath('elm:expression/@xsi:type').to_s
+	}}
+	# puts report
+	report
+end
+
+def composite_validations(doc)
+	report = {
+		doc: doc,
+		title: doc.xpath("//xmlns:title/@value").first.to_s,
+		artifactType: doc.xpath("//xmlns:artifactType/@value").first.to_s,
+		metadata: extract_metadata(doc),
+		
+	}
+	# report[:artifacts] = 
+	xml = doc.xpath('//xmlns:containedArtifacts').to_s
+	# byebug
+	# puts xml
+	report[:artifacts] = Hash.from_xml(xml)[:containedArtifacts][:artifact]
+	# puts report
+	report
+end
+
+
+def	static_manifest_validations(root, manifest)
+	knarts = {}
+	composites = {}
+	manifest['groups'].each do |group|
+		group['items'].each do |item|
+			path = "#{root}/#{item['path']}"
+			# puts "#{path}"
+			if KNART_MIME_TYPES.include? item['mimeType']
+				doc = Nokogiri::XML(File.open(path))
+				begin
+					knarts[item['path']] = knart_validations(doc)
+					# puts knarts[item['path']][:metadata]
+				rescue
+					knarts[item['path']] = {
+						error: "Could not be validated"
+					}
+				end
+			elsif COMPOSITE_MIME_TYPES.include? item['mimeType']
+				doc = Nokogiri::XML(File.open(path))
+				begin
+					composites[item['path']] = composite_validations(doc)
+					# puts composites[item['path']][:metadata]
+				rescue
+					composites[item['path']] = {
+						error: "Could not be validated"
+					}
+				end
+			end
+		end
+	end
+	[knarts, composites]
+end
+
+
+
+def render_results(manifest, root, knarts, composites, out)
+	html = render_partial('spot_check.slim', {root: '..', manifest: manifest, knarts: knarts, composites: composites})
+	# html = Jade.compile File.read(template), locals: {results: results}
+	# puts html
+	file = File.open(out, 'w')
+	file.write html
+	file.close
+end
+
+if(ARGV.length != 2)
+	puts HELP
+	exit 1
+else
+	file = ARGV[0]
+	manifest = JSON.parse(File.read(file))
+	root = File.dirname(File.expand_path(file))
+	knarts, composites = static_manifest_validations(root, manifest)
+	Slim::Engine.set_options pretty: true
+	render_results(manifest, root, knarts, composites, ARGV[1])
+	exit 0
+end

data/bin/update_manifest

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'pp'
+require 'byebug'
+
+require_relative '../lib/common'
+include Repository
+HELP = <<EOF.freeze
+
+Updates an existing repository manifest.json file by merging in any additional files found in the root directory. If the existing and new manifest files are the same, the existing file will be *overwriten* in place. Be sure you have a backup handy if you're doing this!
+
+	USAGE: #{__FILE__} <content_root_directory> <existing_manifest.json> <new_manifest.json>
+
+	EXAMPLE:
+		#{__FILE__} . manifest.json manifest-new.json
+
+EOF
+
+def improveify_name!(item)
+  case item['path']
+  when /CCWP_/
+    item['name'] = 'Clinical Content White Paper'
+  when /HIMKWP_/
+    item['name'] = 'Harmonize and Integrate Member KNARTs White Paper'
+  when /ECA_/
+    item['name'] = 'ECA'
+  when /DT_/
+    item['name'] = 'Documentation Template'
+  when /OS_/
+    item['name'] = 'Order Set'
+  when /CRCK_/
+    item['name'] = 'Composite Artifact'
+  else
+    # Keep the existing name
+  end
+
+  case item['path']
+  when /KVRpt_/
+    item['name'] += ' Validation Report'
+  when /CSD_/
+    item['name'] += ' Conceptual Structure Document'
+  end
+end
+
+def existing_manifest_item_for(item, existing)
+  existing_item = nil
+  existing['groups'].each do |group, _i|
+    # puts "NAME: #{group['name']}"
+    # puts group
+    group['items'].each do |n|
+      if n['path'] == item['path']
+        existing_item = n
+        break
+      end
+    end
+  end
+  existing_item
+end
+
+def existing_manifest_group_for(name, existing)
+  existing_group = nil
+  existing['groups'].each do |group, _i|
+    # puts "#{name} #{group['name']}"
+    if group['name'].casecmp(name).zero?
+      existing_group = group
+      break
+    end
+  end
+  existing_group
+end
+
+# Forces keys to strings.
+def rekey(hash)
+  hash.collect { |k, v| [k.to_s, v] }.to_h
+end
+
+# If the item path is already present *somewhere* in the manifest it will not be merged in, regardless of any differences in the generated and existing item summary. This is intentional to prevent manual changes from being overwritten. Merged in items will be grouped into a group name matching the item name; if an existing group cannot be identified, they will be put into a special placeholder group.
+def merge_items_into(items, existing)
+  updated = []
+  placed = []
+  # placed_into_placeholder_group = []
+
+  items.each do |item|
+    placeholder_group = nil
+    if placeholder_group = existing_manifest_group_for(item['name'], existing)
+      # It already exists. Great.
+    elsif placeholder_group = existing_manifest_group_for(item['name'], existing)
+      # The placeholder group has already been created. Yay.
+    else
+      placeholder_group = rekey(
+        'name': item['name'],
+        'status': 'generated',
+        'items': []
+      )
+      puts "Adding placeholder group to manifest: #{placeholder_group}"
+      existing['groups'] << placeholder_group
+    end
+
+    if existing_item = existing_manifest_item_for(item, existing)
+		# Updated security object only
+		# byebug
+		existing_item['security'] = item['security']
+		updated << existing_item
+    else
+      existing_group = existing_manifest_group_for(item['name'], existing)
+      # Just drop the item into the existing group.
+      improveify_name!(item)
+      # puts "#{item['name']} (#{item['path']})"
+      existing_group['items'] << item
+      placed << item
+      # else
+      #   # No group in the existing manifest appears to be a fit, so put the item into a placeholder group.
+      #   placeholder_group['items'] << item
+      #   placed_into_placeholder_group << item
+    end
+  end
+  [updated, placed]
+end
+
+def report(updated, placed)
+  puts "\nFiles updated as already present in the manifest: #{updated.length}"
+  # updated.each do |n| puts "\t#{n['path']} (#{n['name']})" end
+  puts "Placed into a group: #{placed.length}"
+  placed.each { |n| puts "\t#{[n['path'], n['url']].join(' ')}" }
+  # puts "\nPut into a placeholder group:#{placed_into_placeholder_group.length}"
+  # placed_into_placeholder_group.each do |n| puts "\t#{n['path']}" end
+end
+
+def write_to_file(path, existing)
+  file = File.open(path, 'w')
+  file.write(JSON.pretty_generate(existing))
+  file.close
+end
+
+if ARGV.length != 3
+  puts HELP
+  exit 1
+else
+  file = File.read(ARGV[1])
+  existing = JSON.parse(file)
+  items = content_directory_to_item_tree(ARGV[0])
+  updated, placed = merge_items_into(items, existing)
+  report(updated, placed)
+  write_to_file(ARGV[2], existing)
+  exit 0
+end

data/knartform.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name        = 'knartform'
+  s.version     = '0.6.0'
+  s.summary     = "HL7 CDS Knowledge Artifacts"
+  s.description = "Tools form working with HL7 CDS Knowledge Artifacts."
+  s.authors     = ["Preston Lee"]
+  s.email       = 'preston.lee@prestonlee.com'
+  s.homepage    = 'https://github.com/preston/knartform'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.add_dependency 'nokogiri'
+  s.add_dependency 'httparty'
+  s.add_dependency 'slim'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+end

data/lib/common.rb

@@ -0,0 +1,264 @@
+# require 'xml/libxml'
+require 'digest'
+
+module Repository
+	SUPPORTED_MIME_TYPES = {
+		"application/pdf": {name: "PDF", expression: /\.pdf$/i},
+		"text/html": {name: "HTML", expression: /\.html?$/i},
+		"application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+			{name: "Word", expression: /\.docx?$/i},
+		"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+			{name: "Excel", expression: /\.xlsx?$/i},
+		"application/hl7-cds-knowledge-artifact-1.3+xml": {name: 'HL7 KNART v1.3', expression: /KRprt(?!_CRCK).*\.xml$/i},
+		"application/docbook": {name: 'DocBook', expression: /(HIMKWP|KVRpt|CSD).*\.xml$/i},
+		'application/hl7-cds-knowledge-artifact-composite+xml': {name: 'Composite Artifact', expression: /CRCK_.*\.xml$/i},
+		'image/svg+xml': {name: "SVG Image", expression: /\.svg$/i}
+	  }
+	
+	KNART_MIME_TYPES = [
+		"application/hl7-cds-knowledge-artifact-1.3+xml"
+	  ]
+
+	COMPOSITE_MIME_TYPES = [
+		'application/hl7-cds-knowledge-artifact-composite+xml'
+	  ]
+
+
+DIGRAPH_TEMPLATE = <<TEMPLATE
+digraph {
+	<% artifacts.each do |a| %>
+	artifact_<%= a[:hash] %>[label="<%= a[:name] %>\n<%= a[:file] %>", shape=rounded, style=filled, fillcolor=lightblue]<% end %>
+
+	<% events.each do |k, v| %>
+	event_<%= v %>[label="<%= k %>", style=filled, fillcolor=yellow]<% end %>
+	
+	<% artifacts.each do |a| %><% a[:emits].each do |e| %>
+	artifact_<%= a[:hash] %> -> event_<%= events[e[:name]] %>[fontsize=8, label="emits\n<%= e[:conditions] %>"]<% end %><% end %>
+	<% artifacts.each do |a| %><% a[:triggers].each do |t| %>
+	event_<%= events[t] %> -> artifact_<%= a[:hash] %>[label="triggers"]<% end %><% end %>
+}
+TEMPLATE
+
+def generate_dot(doc)
+	artifacts = []
+	events = {}
+	doc.xpath('//xmlns:containedArtifacts/xmlns:artifact').each do |a|
+		name = a.xpath('./xmlns:name/@value').to_s
+		file = a.xpath('./xmlns:reference/xmlns:url/@address').to_s
+		file = '(embedded)' if file.empty?
+		triggers = []
+		emits = []
+		tmp = {
+			name: name,
+			hash: Digest::SHA1.hexdigest(name),
+			file: file,
+			triggers: triggers,
+			emits: emits
+		}
+		artifacts << tmp
+
+		# Search for triggers
+		# puts a
+		a.xpath('.//xmlns:triggers/xmlns:trigger/@onEventName').each do |t|
+			value = t.to_s
+			triggers << value
+			events[value] = Digest::SHA1.hexdigest(value)
+		end
+
+		# Emmitted events within embedded KNARTs.
+		a.xpath('./xmlns:knowledgeDocument//xmlns:simpleAction[@xsi:type="FireEventAction"]').each do |action|
+			conditions = action.xpath('./xmlns:conditions').to_s.gsub('"', '\"')
+			# puts conditions
+			action.xpath('.//elm:element[@name="EventName"]/elm:value/@value').each do |n|
+				value = n.to_s
+				emits << {
+					name: value,
+					conditions: conditions
+				}
+				events[value] = Digest::SHA1.hexdigest(value)
+			end
+		end
+
+		# Emmitted events for referencesd KNARTs.
+		a.xpath('./xmlns:onCompletion//xmlns:eventName/@name').each do |n|
+			value = n.to_s
+			emits << {
+				name: value,
+				conditions: '(always)'
+			}
+			events[value] = Digest::SHA1.hexdigest(value)
+		end
+		
+
+	end
+	# puts artifacts
+	# puts events
+	renderer = ERB.new(DIGRAPH_TEMPLATE)
+	renderer.result(binding)
+end
+
+	# Forces keys to strings.
+	def rekey(hash)
+		hash.collect{|k,v| [k.to_s, v]}.to_h
+	end
+
+	def mimeTypeForFile(path)
+		mimeType = nil
+		SUPPORTED_MIME_TYPES.each do |k,v|
+			if v[:expression].match?(path)
+				mimeType = k
+				break
+			end
+		end
+		# puts mimeType || path
+		mimeType
+	end
+
+	def content_directory_to_item_tree(root)
+		content = []
+		list = Dir["#{root}/**/**"]
+		list.each do |n|
+			# puts n
+			if(File.file?(n))
+				# ext = File.extname(n).downcase[1..-1]
+				mimeType = mimeTypeForFile(n)
+				name = n.split('/')[1] #.split['.'][0]
+				name = name.split('_').collect(&:capitalize).join(' ')
+				tags = n.split('/').select{|d| d.length <= 4}
+				# Add subdirectory names to the tag list
+				subs = Dir.glob(File.dirname(n) + '/*').select{ |t|
+					puts t
+					# puts					File.directory?(t)
+					# puts	File.dirname(n) != t
+					# byebug
+					File.directory?(t) && n != t
+				}.collect{ |t| File.basename(t)}
+				puts "#{n} SUBS: #{subs}"
+				tags |= subs
+				if mimeType # it's a supported piece of content
+					item = {
+						'name': name,
+						'path': n,
+						'mimeType': mimeType,
+						'tags': tags
+					}
+					update_security(item)
+					item = rekey(item)
+					# Any directory name of 4 characters or less will be treated as a tag automatically
+					content << item
+				end
+			end
+		end
+		content
+	end
+
+	def	update_security(item)
+		# byebug
+		content = File.read(item[:path])
+		item['security'] = rekey({
+			sha1: Digest::SHA1.hexdigest(content),
+			sha256: Digest::SHA256.hexdigest(content),
+			md5: Digest::MD5.hexdigest(content)
+		})
+		puts item
+	end
+	
+	def audit_content_directory(root, manifest)
+		good = []
+		bad = []
+		manifest['groups'].each do |group|
+			group['items'].each do |item|
+				if item['path']
+					path = "#{root}/#{item['path']}"
+					if File.exist? path
+						good << item
+					else
+						bad << item
+					end
+				end
+				begin
+					if item['url']
+						response = HTTParty.head(item['url'])
+						if(response.code >= 400)
+							bad << item
+						else
+							good << item
+						end
+					end
+				rescue SocketError => e
+					# Probably a bad DNS or protocol name.
+					bad << item
+				end
+			end
+		end
+		return [good, bad]
+
+	end
+
+	def render_partial(name, stuff)
+		template = File.join(File.dirname(File.expand_path(__FILE__)), name)
+		Slim::Template.new(template).render(self, stuff)
+	end
+	
+end
+
+# USAGE: Hash.from_xml(YOUR_XML_STRING)require 'rubygems'
+require 'nokogiri'
+# modified from http://stackoverflow.com/questions/1230741/convert-a-nokogiri-document-to-a-ruby-hash/1231297#1231297
+
+class Hash
+  class << self
+    def from_xml(xml_io)
+      begin
+        result = Nokogiri::XML(xml_io)
+        return { result.root.name.to_sym => xml_node_to_hash(result.root)}
+      rescue Exception => e
+        # raise your custom exception here
+      end
+    end
+
+    def xml_node_to_hash(node)
+      # If we are at the root of the document, start the hash 
+      if node.element?
+        result_hash = {}
+        if node.attributes != {}
+          attributes = {}
+          node.attributes.keys.each do |key|
+            attributes[node.attributes[key].name.to_sym] = node.attributes[key].value
+          end
+        end
+        if node.children.size > 0
+          node.children.each do |child|
+            result = xml_node_to_hash(child)
+
+            if child.name == "text"
+              unless child.next_sibling || child.previous_sibling
+                return result unless attributes
+                result_hash[child.name.to_sym] = result
+              end
+            elsif result_hash[child.name.to_sym]
+
+              if result_hash[child.name.to_sym].is_a?(Object::Array)
+                 result_hash[child.name.to_sym] << result
+              else
+                 result_hash[child.name.to_sym] = [result_hash[child.name.to_sym]] << result
+              end
+            else
+              result_hash[child.name.to_sym] = result
+            end
+          end
+          if attributes
+             #add code to remove non-data attributes e.g. xml schema, namespace here
+             #if there is a collision then node content supersets attributes
+             result_hash = attributes.merge(result_hash)
+          end
+          return result_hash
+        else
+          return attributes
+        end
+      else
+        return node.content.to_s
+      end
+    end
+  end
+end