adiwg-mdtranslator 1.4.0 → 2.0.0rc2

data/lib/adiwg/mdtranslator/writers/mdJson/sections/mdJson_voucher.rb

@@ -0,0 +1,29 @@
+# mdJson 2.0 writer - taxonomic voucher
+
+# History:
+#   Stan Smith 2017-03-17 original script
+
+require 'jbuilder'
+require_relative 'mdJson_responsibleParty'
+
+module ADIWG
+   module Mdtranslator
+      module Writers
+         module MdJson
+
+            module Voucher
+
+               def self.build(hVoucher)
+
+                  Jbuilder.new do |json|
+                     json.specimen hVoucher[:specimen]
+                     json.repository ResponsibleParty.build(hVoucher[:repository]) unless hVoucher[:repository].empty?
+                  end
+
+               end # build
+            end # Voucher
+
+         end
+      end
+   end
+end

data/lib/adiwg/mdtranslator/writers/mdJson/version.rb

@@ -1,13 +1,17 @@
+# History version 2
+#  Stan Smith 2017-03-10 refactored for mdJson/mdTranslator 2.0
+
+# History version 1
+#  Josh Bradley
+
 module ADIWG
-    module Mdtranslator
-        module Writers
-            module MdJson
+   module Mdtranslator
+      module Writers
+         module MdJson
 
-                # current version of mdJson writer,
-                # corresponds to mdJson output
-                VERSION = '1.1.0'
+            VERSION = '2.0.0'
 
-            end
-        end
-    end
+         end
+      end
+   end
 end

data/lib/adiwg/mdtranslator/writers/mdWriters.rb

@@ -1,61 +1,69 @@
 # MdTranslator - controller for evaluating and directing writers
 
 # History:
-# 	Stan Smith 2014-12-11 original script
-#   Stan Smith 2012-12-16 generalized handleWriter to use :writerName
-#   Stan Smith 2015-03-04 changed method of setting $WriterNS
-#   Stan Smith 2015-06-22 replace global ($response) with passed in object (responseObj)
-#   Stan Smith 2015-07-14 refactored to make iso19110 independent of iso19115_2 classes
+#   Stan Smith 2016-11-14 refactored for mdTranslator 2.0.0
 #   Stan Smith 2015-07-14 refactored to eliminate namespace globals $WriterNS and $IsoNS
+#   Stan Smith 2015-07-14 refactored to make iso19110 independent of iso19115_2 classes
+#   Stan Smith 2015-06-22 replace global ($response) with passed in object (hResponseObj)
+#   Stan Smith 2015-03-04 changed method of setting $WriterNS
+#   Stan Smith 2012-12-16 generalized handleWriter to use :writerName
+#   Stan Smith 2014-12-11 original script
 
 module ADIWG
     module Mdtranslator
         module Writers
 
-            def self.handleWriter(intObj, responseObj, paramsObj)
+            def self.handleWriter(intObj, hResponseObj)
 
-                # use writerName from responseObj to build directory path to writer
-                # the writer's high level folder must be under the 'writers' directory
-                writerDir = File.join(path_to_writers, responseObj[:writerName])
+                # use ':writerRequested' from hResponseObj to build directory path to writer
+                # writer's high-level folder must be placed in 'lib/adiwg/mdtranslator/writers/'
+                # writer's code must must be in folder named '{writer}'
+                # '{writer}' must contain a module named '{writer}_writer.rb'
+                # '{writer}_writer.rb' must have a method named 'startWriter()'
+                # 'startWriter()' must pass two parameters (intObj, hResponseObj)
+                # all writer modules and classes must remain in their private namespace
+                # writer namespace is 'ADIWG::Mdtranslator::Writers::{writer}'
+
+                # the writer's high-level
+                thisDir = File.dirname(File.expand_path(__FILE__))
+                writerDir = File.join(thisDir, hResponseObj[:writerRequested])
                 if File.directory?(writerDir)
 
-                    # if directory path exists, build writer file name and require it
-                    writerFile = File.join(writerDir, responseObj[:writerName] + '_writer')
-                    require writerFile
+                    # writer folder
+                    writerModule = File.join(writerDir, hResponseObj[:writerRequested] + '_writer')
+                    require writerModule
 
-                    # build the namespace for the writer
-                    writerNS = responseObj[:writerName].dup
+                    # writer namespace
+                    writerNS = hResponseObj[:writerRequested].dup
                     writerNS[0] = writerNS[0].upcase
 
-                    # pass internal object and response object to the writer
-                    responseObj[:writerOutput] = ADIWG::Mdtranslator::Writers.const_get(writerNS).startWriter(intObj, responseObj, paramsObj)
+                    # pass internal object and hResponseObj to the writer
+                    hResponseObj[:writerOutput] = ADIWG::Mdtranslator::Writers.const_get(writerNS).startWriter(intObj, hResponseObj)
 
                 else
-                    # directory path was not found
-                    responseObj[:writerPass] = false
-                    responseObj[:writerMessages] << 'Writer not called - see following message(s):\n'
-                    responseObj[:writerMessages] << "Writer name '#{responseObj[:writerName]}' is not supported."
-                    return false
+                    hResponseObj[:writerMessages] << "Requested writer '#{hResponseObj[:writerRequested]}' cannot be found."
+                    hResponseObj[:writerPass] = false
                 end
 
-            end
+                return hResponseObj
 
-            # return path to writers
-            def self.path_to_writers
-                File.dirname(File.expand_path(__FILE__))
             end
 
             # return writer readme text
             # this is called from the Rails API
             def self.get_writer_readme(writer)
-                readmeText = 'No readme found'
-                path = File.join(path_to_writers, writer, 'readme.md')
+
+                thisDir = File.dirname(File.expand_path(__FILE__))
+                path = File.join(thisDir, writer, 'readme.md')
                 if File.exist?(path)
                     file = File.open(path, 'r')
                     readmeText = file.read
                     file.close
+                    return readmeText
+                else
+                    return 'Readme file not found'
                 end
-                return readmeText
+
             end
 
         end

data/lib/adiwg/mdtranslator.rb

@@ -1,156 +1,178 @@
-# MdTranslator - ADIwg MdTranslator RubyGem entry point
+# MdTranslator - ADIwg MdTranslator entry point
 
 # History:
-# 	Stan Smith 2014-07-02 original script
-#   Stan Smith 2014-07-21 added ADIWG namespace
-#   Stan Smith 2014-07-21 added validation of json structure
+#   Stan Smith 2016-11-11 refactor for mdTranslator 2.0
+#   Stan Smith 2015-07-17 added support for user supplied CSS for html writer
+#   Stan Smith 2015-07-16 moved module_coordinates from mdJson reader to internal
+#   Stan Smith 2015-07-14 renamed readerVersionFound to readerVersionRequested
+#   Stan Smith 2015-07-14 deleted readerFound
+#   Stan Smith 2015-06-22 replace global ($response) with passed in object (hResponseObj)
+#   ... created as an instance of class ResponseHash
+#   Stan Smith 2015-03-04 moved addFinalMessages into this module from rails app
+#   Stan Smith 2015-01-15 changed translate() to keyword parameter list
+#   Stan Smith 2014-12-11 refactored to handle namespacing readers and writers
+#   Stan Smith 2014-12-02 organized shared class/code/units folders for 19115-2, 19110
+#   Stan Smith 2014-12-01 added translator version to $response
+#   Stan Smith 2014-12-01 added writer iso19110 (feature catalogue)
+#   Stan Smith 2014-12-01 changed adiwgJson to mdJson
+#   Stan Smith 2014-10-11 added methods to return content of readme files
+#   Stan Smith 2014-10-10 added method to return path to readers and writers
+#   Stan Smith 2014-09-26 added processing of minor release numbers
 #   Stan Smith 2014-07-23 moved all validations to readers/adiwg/adiwg_validator.rb
 #   ... each reader will have it's own validator
-#   Stan Smith 2014-09-26 added processing of minor release numbers
-#   Stan Smith 2014-10-10 added method to return path to readers and writers
-#   Stan Smith 2014-10-11 added methods to return content of readme files
-#   Stan Smith 2014-12-01 changed adiwgJson to mdJson
-#   Stan Smith 2014-12-01 added writer iso19110 (feature catalogue)
-#   Stan Smith 2014-12-01 added translator version to $response
-#   Stan Smith 2014-12-02 organized shared class/code/units folders for 19115-2, 19110
-#   Stan Smith 2014-12-11 refactored to handle namespacing readers and writers
-#   Stan Smith 2015-01-15 changed translate() to keyword parameter list
-#   Stan Smith 2015-03-04 moved addFinalMessages into this module from rails app
-#   Stan Smith 2015-06-22 replace global ($response) with passed in object (responseObj)
-#   ... created as an instance of class ResponseHash
-#   Stan Smith 2015-07-14 deleted readerFound
-#   Stan Smith 2015-07-14 renamed readerVersionFound to readerVersionRequested
-#   Stan Smith 2015-07-16 moved module_coordinates from mdJson reader to internal
-#   Stan Smith 2015-07-17 added support for user supplied CSS for html writer
+#   Stan Smith 2014-07-21 added validation of json structure
+#   Stan Smith 2014-07-21 added ADIWG namespace
+# 	Stan Smith 2014-07-02 original script
 
 # required by readers and writers
 require 'adiwg/mdtranslator/version'
 require 'adiwg/mdtranslator/readers/mdReaders'
 require 'adiwg/mdtranslator/writers/mdWriters'
-require 'adiwg/mdtranslator/internal/internal_metadata_obj'
-require 'adiwg/mdtranslator/internal/module_dateTimeFun'
-require 'adiwg/mdtranslator/internal/module_geoFormat'
-require 'adiwg/mdtranslator/internal/module_coordinates'
-require 'adiwg/mdtranslator/internal/module_point'
-require 'adiwg/mdtranslator/internal/module_lineString'
 
 module ADIWG
     module Mdtranslator
 
-        def self.translate(file:, reader:, validate: 'normal', writer: nil, showAllTags: false, css: nil, cssLink: nil)
+        def self.translate(file:, reader: 'mdJson', writer: nil, validate: 'normal', showAllTags: false, cssLink: nil)
 
-            # the reader and writer specified in the translate parameter string should load and
+            # the reader and writer specified in the translate module parameter string will load and
             #     return this hash ...
+            # ====================================================================================
+            # readerRequested: name of the reader requested by the user
+            #   - set from the parameter list (reader) (default = 'mdJson')
+            # ------------------------------------------------------------------------------------
+            # readerVersionRequested: version of the reader requested in input file
+            #   - set in reader
+            # ------------------------------------------------------------------------------------
+            # readerVersionUsed: actual reader version use in processing the input file
+            #   - set by the reader
+            # ------------------------------------------------------------------------------------
+            # readerStructurePass: false if input file structure is determined to be invalid
+            #   - set by the reader
+            # ------------------------------------------------------------------------------------
+            # readerStructureMessages: an array of parser warning and error messages
+            #   - set by the reader
             # ------------------------------------------------------------------------------------
-            # readerFormat: the anticipated format of the input file, parsing by the reader will
-            #     proceed assuming this format, set by reader
-            # readerStructurePass: 'true' if input file structure is determined to be valid.
-            #    Set by the reader.
-            # readerStructureMessages: an array of quoted string messages. If readerStructurePass
-            #    is false, set one or more messages to assist the user in fixing file structure
-            #    problems.  Set by reader.
-            # readerRequested: name of the reader requested by the user, set from  the translate
-            #    parameter list
-            # readerVersionRequested: version of the reader requested by the input file, set by reader
-            # readerVersionUsed: version of the reader the reader method decided to use in processing
-            #    the input file.  Set by the reader.  Default 'normal'.
             # readerValidationLevel: validation level requested to be applied to the input file, set
-            #    from the parameter list
-            # readerValidationPass: true if the input file passes the level of validation requested,
-            #    set by reader
-            # readerValidationMessages: an array of quoted string messages. If readerValidationPass
-            #    is 'false', set one or more messages to assist user fixing file schema validation
-            #    problems.  Set by reader.
-            # readerExecutionPass: 'true' if the reader completes the import of the input file into
-            #    the internal object without errors. set by reader.
-            # readerExecutionMessages: an array of quoted string messages. If readerExecutionPass is
-            #    'false', set one or more messages to assist user in fixing file data problems.
-            #    Set by reader.
-            # writerName: name of the writer requested by the user, set from the translate parameter
-            #    list.  if nil no write was requested and only validation of the input file will
-            #    be performed.
-            # writerVersion: current version of the writer requested, set by writer
-            # writerFormat: format of the output from the writer. Set by writer.
-            # writerPass: true if the writer completes the creation of the output file without errors,
-            #    set by writer
-            # writerMessages: an array of quoted string messages.  If writerPass is 'false', set one
-            #    or more messages to assist user in fixing file data problems.  Set by writer.
-            # writerOutput: output file returned from the writer, set by writer
-            # writerShowTags: include tags in XML output for empty elements
-            # writerMissingIdCount: counter for creating unique elements IDs for ISO elements that did not
-            #    provide IDs in the input metadata file
+            #   - set from the parameter list (reader)
+            # ------------------------------------------------------------------------------------
+            # readerValidationPass: false if fails requested level of validation
+            #   - set by the reader
+            # ------------------------------------------------------------------------------------
+            # readerValidationMessages: an array of schema warning and error messages
+            #   - set by the reader
+            # ------------------------------------------------------------------------------------
+            # readerExecutionPass: false if the reader finds fatal errors in input file
+            #   - set by the reader
+            # ------------------------------------------------------------------------------------
+            # readerExecutionMessages: an array of reader warning and error messages
+            #   - set by the reader
+            # ------------------------------------------------------------------------------------
+            # writerRequested: name of the writer requested by the user
+            #   - set from the parameter list (writer)
+            # ------------------------------------------------------------------------------------
+            # writerVersion: current version of the requested writer
+            #   - set by the writer
+            # ------------------------------------------------------------------------------------
+            # writerFormat: format of writer output
+            #   - set by the writer
+            # ------------------------------------------------------------------------------------
+            # writerPass: false if the writer fails to complete creation of output file
+            #   - set by the writer
+            # ------------------------------------------------------------------------------------
+            # writerMessages: an array of writer warning and error messages
+            #   - set by the writer
+            # ------------------------------------------------------------------------------------
+            # writerOutput: the output file returned by the writer
+            #   - set by the writer
+            # ------------------------------------------------------------------------------------
+            # writerShowTags: include tags in XML output for any empty elements
+            #   - set from the parameter list (showAllTags)
+            # ------------------------------------------------------------------------------------
+            # writerCSSlink: CSS link to append to HTML writer output
+            #   - set from the parameter list (showAllTags)
+            # ------------------------------------------------------------------------------------
+            # writerMissingIdCount: counter for creating unique element IDs as needed
+            #   - set by the writer
+            # ------------------------------------------------------------------------------------
             # translatorVersion: current version of the mdTranslator
+            #   - set by the translator
+            # ------------------------------------------------------------------------------------
 
-            responseObj =  {
-                readerFormat: nil,
-                readerStructurePass: nil,
-                readerStructureMessages: [],
+            hResponseObj =  {
                 readerRequested: nil,
                 readerVersionRequested: nil,
                 readerVersionUsed: nil,
+                readerStructurePass: true,
+                readerStructureMessages: [],
                 readerValidationLevel: nil,
-                readerValidationPass: nil,
+                readerValidationPass: true,
                 readerValidationMessages: [],
-                readerExecutionPass: nil,
+                readerExecutionPass: true,
                 readerExecutionMessages: [],
-                writerName: nil,
-                writerVersion: nil,
-                writerFormat: nil,
-                writerPass: nil,
+                writerRequested: nil,
+                writerPass: true,
                 writerMessages: [],
+                writerOutputFormat: nil,
                 writerOutput: nil,
                 writerShowTags: false,
+                writerCSSlink: nil,
                 writerMissingIdCount: '_000',
                 translatorVersion: nil
             }
 
-            paramsObj = {
-                cssLink: cssLink,
-                css: css
-            }
+            # parameter - file (required)
+            if file.nil? || file == ''
+                hResponseObj[:readerExecutionPass] = false
+                hResponseObj[:readerExecutionMessages] << "Parameter 'file:' was not provided"
+                return hResponseObj
+            end
 
-            # add the passed in parameters to the response hash
-            responseObj[:readerRequested] = reader
-            responseObj[:readerValidationLevel] = validate
-            responseObj[:writerName] = writer
-            responseObj[:writerShowTags] = showAllTags
+            # parameter - reader (required)
+            if reader == ''
+                hResponseObj[:readerExecutionPass] = false
+                hResponseObj[:readerExecutionMessages] << "Parameter 'reader:' was not provided"
+                return hResponseObj
+            end
+
+            # add passed in parameters to the response hash
+            hResponseObj[:readerRequested] = reader
+            hResponseObj[:readerValidationLevel] = validate
+            hResponseObj[:writerRequested] = writer
+            hResponseObj[:writerShowTags] = showAllTags
+            hResponseObj[:writerCSSlink] = cssLink
 
             # add mdTranslator version to response hash
-            responseObj[:translatorVersion] = ADIWG::Mdtranslator::VERSION
-
-            # handle readers
-            if reader.nil? || reader == ''
-                responseObj[:readerExecutionPass] = false
-                responseObj[:readerExecutionMessages] << 'Reader name was not provided'
-                return responseObj
-
-            else
-                intObj = ADIWG::Mdtranslator::Readers.handleReader(file, responseObj)
-
-                # if readerValidation failed - exit
-                if !responseObj[:readerValidationPass]
-                    return responseObj
-                end
-
-                # if readerExecutionPass is nil no error messages were set while
-                # reading the input file into the internal object.
-                # the read operation is assumed to have been successful and pass is set to true.
-                if responseObj[:readerExecutionPass].nil?
-                    responseObj[:readerExecutionPass] = true
-                elsif !responseObj[:readerExecutionPass]
-                    return responseObj
-                end
+            hResponseObj[:translatorVersion] = ADIWG::Mdtranslator::VERSION
+
+            # handle reader
+            intObj = ADIWG::Mdtranslator::Readers.handleReader(file, hResponseObj)
+
+            # if reader file structure failed - exit
+            if hResponseObj[:readerStructurePass] === false
+                return hResponseObj
+            end
+
+            # if reader file validation failed - exit
+            if hResponseObj[:readerValidationPass] === false
+                return hResponseObj
+            end
+
+            # if reader file execution failed - exit
+            if hResponseObj[:readerExecutionPass] === false
+                return hResponseObj
             end
 
-            # handle writers
+            #handle writers
             if writer.nil? || writer == ''
-                responseObj[:writerMessages] << 'Writer name was not provided.'
-            else
-                require File.join(File.dirname(__FILE__), 'mdtranslator/writers/mdWriters')
-                ADIWG::Mdtranslator::Writers.handleWriter(intObj, responseObj, paramsObj)
+                hResponseObj[:writerMessages] << "Parameter 'writer:' was not provided"
+                hResponseObj[:writerPass] = false
+                return hResponseObj
             end
 
-            return responseObj
+            require File.join(File.dirname(__FILE__), 'mdtranslator/writers/mdWriters')
+            ADIWG::Mdtranslator::Writers.handleWriter(intObj, hResponseObj)
+
+            return hResponseObj
 
         end
 

data/lib/adiwg/mdtranslator_cli.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+# ADIwg mdTranslator - Thor CLI for mdtranslator
+
+# History:
+#  Stan Smith 2017-04-21 removed inline CSS option
+#  Stan Smith 2015-07-17 added method_options to provide custom CSS
+#  Stan Smith 2014-01-16 changed ADIWG::Mdtranslator.translate() to keyword parameter list
+#  Stan Smith 2014-12-29 changed default reader from adiwgJson to mdJson
+#  Stan Smith 2014-10-09 added version command to the CLI
+#  Stan Smith 2014-09-21 coded cli to 0.8.0 api
+#  Stan Smith 2014-09-02 changed name to mdtranslator
+# 	Stan Smith 2014-07-15 original script
+
+require 'thor'
+
+class MdtranslatorCLI < Thor
+
+   # exit_on_failure added to exit with code 1 if thor cannot complete task
+   # such as if required parameters are missing
+   def self.exit_on_failure?
+      true
+   end
+
+   # basic cli description
+   desc 'translate [FILE]', %q{Pass JSON string or filename plus parameters to mdtranslator translate}
+   long_desc <<-LONGDESC
+	'mdtranslator translate' provides command line access to the ADIwg metadata translator, mdTranslator.  The 'translate'
+method converts input metadata to supported established metadata metadata formats.  The CLI accepts an input metadata
+file with options to select the input reader format, writer output format, display empty tags in XML outputs, and choose
+level of validation for mdJson input files.
+   LONGDESC
+   # define cli options
+   method_option :reader, :aliases => '-r', :desc => 'Reader to read your input metadata file', :enum => %w{mdJson sbJson}, :required => true
+   method_option :writer, :aliases => '-w', :desc => 'Writer to create your output metadata file, leave blank to validate input only', :enum => %w{iso19115_2 iso19110 html mdJson sbJson}
+   method_option :validate, :aliases => '-v', :desc => 'Specify level of validation to be performed', :enum => %w{none normal strict}, :default => 'normal'
+   method_option :showAllTags, :aliases => '-s', :desc => 'Include tags for unused attributes', :type => :boolean, :default => false
+   method_option :messages, :aliases => '-m', :desc => 'On error return messages as formatted text or json object', :enum => %w{json text}, :default => 'text'
+   method_option :returnObject, :aliases => '-o', :desc => 'Return full JSON object generated by translator', :type => :boolean, :default => false
+   method_option :cssLink, :desc => 'Fully qualified link to a CSS file to customize HTML writer output', :type => :string
+
+   # accept command and options
+   def translate(file)
+
+      # test to see if file parameter is a local file name
+      # if not ... assumed it is a JSON string
+      # note: this will need to be modified if/when a reader is added that is not in JSON format
+      if File.exist?(file)
+         # read file
+         my_file = File.open(file, 'r')
+         fileObj = my_file.read
+         my_file.close
+      else
+         fileObj = file
+      end
+
+      # for testing parameters
+      # puts 'reader: ' + options[:reader]
+      # puts 'writer: ' + options[:writer]
+      # puts 'validation level: ' + options[:validate]
+      # puts 'showAllTags: ' + options[:showAllTags].to_s
+      # puts 'message format: ' + options[:messages]
+      # puts 'return object: ' + options[:returnObject].to_s
+      # puts 'css link: ' + options[:cssLink]
+
+      # call mdtranslator
+      mdReturn = ADIWG::Mdtranslator.translate(
+         file: fileObj,
+         reader: options[:reader],
+         writer: options[:writer],
+         validate: options[:validate],
+         showAllTags: options[:showAllTags],
+         cssLink: options[:cssLink])
+
+      # determine return content and type of return ...
+      if mdReturn[:readerStructurePass] && mdReturn[:readerValidationPass]
+
+         # no problem was found with the input file
+         if options[:writer].nil?
+            # if no writer was specified the input was being validated only,
+            # ...no writer output will have been generated,
+            # ...and the return will be a string unless json was requested
+            if options[:messages] == 'json'
+               $stdout.write mdReturn.to_json
+               return
+            else
+               $stdout.write 'Success'
+               return
+            end
+         else
+            # a writer was specified,
+            # output is expected from the translator's writer
+            if mdReturn[:writerPass]
+               # writer output was generated
+               # ...return the writer output in its native format unless json was requested
+               if options[:returnObject]
+                  $stdout.write mdReturn.to_json
+                  return
+               else
+                  $stdout.write mdReturn[:writerOutput].to_s
+                  return
+               end
+            else
+               # the writer failed or generated warnings to be reported
+               # ...return the messages as a string unless json was requested
+               if options[:messages] == 'json'
+                  $stdout.write mdReturn.to_json
+                  return
+               else
+                  # build a string with messages issues from parser and validator
+                  s = ''
+                  s += "Failed\n"
+                  s += "Writer failed to generate output or issued significant warnings\n"
+                  s += "See following messages for further information\n"
+
+                  # post structure messages
+                  i = 0
+                  mdReturn[:writerMessages].each do |message|
+                     i += 1
+                     s += "\nMessage: #{i}\n"
+                     s += message + "\n"
+                  end
+
+                  $stdout.write s
+                  return
+
+               end
+            end
+         end
+
+      else
+
+         # problems were found with the input file
+
+         # if no writer was specified the input was being validated only,
+         # ...no writer output will have been generated,
+         # ...and return is always expected to be a string
+         if options[:messages] == 'json'
+            $stdout.write mdReturn.to_json
+            return
+         else
+            # build a string with messages issues from parser and validator
+            s = ''
+            s += "Failed\n"
+            s += "Input failed to pass either file structure validation or content does not match schema\n"
+            s += "See following messages for further information\n"
+
+            # post structure messages
+            if mdReturn[:readerStructurePass]
+               s += "Success - Input structure is valid\n"
+            else
+               s += "Fail - Structure of input file is invalid - see following message(s):\n"
+               i = 0
+               mdReturn[:readerStructureMessages].each do |message|
+                  i += 1
+                  s += "\nMessage: #{i}\n"
+                  s += message.to_s + "\n"
+               end
+            end
+
+            # post validator messages
+            unless mdReturn[:readerValidationPass].nil?
+               if mdReturn[:readerValidationPass]
+                  s += "Success - Input content passes schema definition\n"
+               else
+                  s += "Fail - Input content did not pass schema validation - see following message(s):\n"
+                  i = 0
+                  mdReturn[:readerValidationMessages].each do |message|
+                     i += 1
+                     s += "\nMessage: #{i}\n"
+                     s += message.to_s + "\n"
+                  end
+               end
+            end
+
+            $stdout.write s
+            return
+
+         end
+      end
+
+   end
+
+   desc 'version', %q{Returns the version of mdTranslator}
+   long_desc <<-LONGDESC
+		'mdtranslator version' returns the version number for mdTranslator
+   LONGDESC
+
+   def version
+      $stdout.write ADIWG::Mdtranslator::VERSION
+   end
+end