etna 0.1.27 → 0.1.28

data/lib/etna.rb

@@ -20,6 +20,7 @@ require_relative './etna/csvs'
 require_relative './etna/environment_scoped'
 require_relative './etna/filesystem'
 require_relative './etna/formatting'
+require_relative './etna/cwl'
 
 class EtnaApp
   include Etna::Application

data/lib/etna/clients/magma/formatting.rb

@@ -1 +1,2 @@
-require_relative 'formatting/models_csv'
+require_relative 'formatting/models_csv'
+require_relative 'formatting/models_odm_xml'

data/lib/etna/clients/magma/formatting/models_odm_xml.rb

@@ -0,0 +1,293 @@
+require 'nokogiri'
+
+module Etna
+  module Clients
+    class Magma
+      module ModelsOdmXml
+      end
+    end
+  end
+end
+
+module Etna
+  module Clients
+    class Magma
+      module ModelsOdmXml
+        module Prettify
+          def prettify(name)
+            name.split('_').map(&:capitalize).join(' ')
+          end
+
+          def shorten(name)
+            name.gsub('_', '').capitalize
+          end
+        end
+
+        class Exporter
+          include Prettify
+
+          attr_reader :project_name, :models
+
+          def initialize(project_name:, models:)
+            @project_name = project_name
+            @models = models
+          end
+
+          def data_type_map
+            @data_type_map ||= begin
+              map = {}
+              map[Etna::Clients::Magma::AttributeType::STRING] = 'text'
+              map[Etna::Clients::Magma::AttributeType::DATE_TIME] = 'date'
+              map[Etna::Clients::Magma::AttributeType::BOOLEAN] = 'text'
+              map[Etna::Clients::Magma::AttributeType::FLOAT] = 'float'
+              map[Etna::Clients::Magma::AttributeType::INTEGER] = 'integer'
+
+              map
+            end
+          end
+
+          def redcap_field_type_map
+            @redcap_field_type_map ||= begin
+              map = {}
+              map[Etna::Clients::Magma::AttributeType::STRING] = 'textarea'
+              map[Etna::Clients::Magma::AttributeType::DATE_TIME] = 'text'
+              map[Etna::Clients::Magma::AttributeType::BOOLEAN] = 'radio'
+              map[Etna::Clients::Magma::AttributeType::FLOAT] = 'text'
+              map[Etna::Clients::Magma::AttributeType::INTEGER] = 'text'
+
+              map
+            end
+          end
+
+          def redcap_text_validation_map
+            @redcap_text_validation_map ||= begin
+              map = {}
+              map[Etna::Clients::Magma::AttributeType::DATE_TIME] = 'date_mdy'
+              map[Etna::Clients::Magma::AttributeType::FLOAT] = 'float'
+              map[Etna::Clients::Magma::AttributeType::INTEGER] = 'int'
+
+              map
+            end
+          end
+
+          def write_models(output_io: nil, filename: nil)
+            @document = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+              xml.ODM(odm_headers) do
+                xml.Study(OID: "Project.#{shorten(project_name)}") do
+                end
+                global_variables(xml)
+                metadata(xml)
+              end
+            end
+
+            @document.to_xml
+          end
+
+          def odm_headers
+            {
+              xmlns: "http://www.cdisc.org/ns/odm/v1.3",
+              'xmlns:ds': "http://www.w3.org/2000/09/xmldsig#",
+              'xmlns:xsi': "http://www.w3.org/2001/XMLSchema-instance",
+              'xmlns:redcap': "https://projectredcap.org",
+              'xsi:schemaLocation': "http://www.cdisc.org/ns/odm/v1.3 schema/odm/ODM1-3-1.xsd",
+              ODMVersion: "1.3.2",
+              FileOID: "000-00-0000",
+              FileType: "Snapshot",
+              Description: project_name,
+              AsOfDateTime: DateTime.now,
+              CreationDateTime: DateTime.now,
+              SourceSystem: "Magma",
+              SourceSystemVersion: DateTime.now
+            }
+          end
+
+          def global_variables(xml)
+            # Includes general metadata about the project, as well as
+            # declarations of all repeating instruments,
+            #   which seem like Timepoints to me.
+            # NOTE:
+            # <redcap:Purpose>0</redcap:Purpose>
+            # 0 = Practice / just for fun
+            # 1 = Operational Support
+            # 2 = Research
+            # 3 = Quality Improvement
+            # 4 = Other
+
+            xml.GlobalVariables do
+              xml.StudyName "#{project_name}"
+              xml.StudyDescription "#{project_name} - Data Library integration project"
+              xml.ProtocolName "#{project_name}"
+              xml.send('redcap:RecordAutonumberingEnabled', 1)
+              xml.send('redcap:CustomRecordLabel')
+              xml.send('redcap:SecondaryUniqueField')
+	            xml.send('redcap:SchedulingEnabled', 0)
+	            xml.send('redcap:SurveysEnabled', 0)
+              xml.send('redcap:SurveyInvitationEmailField')
+              xml.send('redcap:Purpose', 2) # 2 == research
+              xml.send('redcap:PurposeOther')
+              xml.send('redcap:ProjectNotes', "Used to easily ingest clinical data for #{project_name} into the Data Library.")
+              xml.send('redcap:MissingDataCodes')
+
+              repeating_instruments(xml)
+            end
+          end
+
+          def repeating_attribute_types
+            # We don't have a good indicator for what is a repeating
+            #   attribute for REDCap...
+            # Will this work for models without timepoint, that go
+            #   straight from subject -> sample?
+            models.model('subject').template.attributes.all.select do |attribute|
+              Etna::Clients::Magma::AttributeType::COLLECTION == attribute.attribute_type
+            end
+          end
+
+          def clinical_dictionaries
+            # Our indicator for if something needs a REDCap form will be any
+            #   model with a dictionary.
+            models.all.select do |model|
+              model.template.raw['dictionary']
+            end.map do |model|
+              model.template.dictionary
+            end
+          end
+
+          def repeating_instruments(xml)
+            # Now we get into repeating instruments and events.
+            # From a Magma model perspective, this should be
+            #   Timepoint that hangs off of
+            #   a Subject model.
+            xml.send('redcap:RepeatingInstrumentsAndEvents') do
+              repeating_attribute_types.map do |repeating_attribute|
+                write_repeating_instrument_xml(xml, repeating_attribute)
+              end
+            end
+          end
+
+          def write_repeating_instrument_xml(xml, instrument)
+            node = xml.send('redcap:RepeatingInstrument')
+            node['redcap:UniqueEventName'] = 'event_1_arm_1'
+            node['redcap:RepeatInstrument'] = instrument.attribute_name
+            node['redcap:CustomLabel'] = instrument.display_name || instrument.attribute_name.capitalize
+
+            node
+          end
+
+          def metadata(xml)
+            # Includes form and field definitions
+            xml.MetaDataVersion(
+              OID: "Metadata.#{shorten(project_name)}_#{DateTime.now}",
+              Name: project_name,
+              'redcap:RecordIdField': 'record_id'
+            ) do
+              clinical_dictionaries.map do |dictionary|
+                # Each Magma dictionary needs a FormDef, with
+                #   ItemGroupRef children for each form page (?).
+                # Each ItemGroupRef requires a corresponding ItemGroupDef
+                #   with ItemRef children for each input (?).
+                # Each ItemRef requires a correspdonding ItemDef
+                #   that defines the label and type, and includes
+                #   <Question> as a label (?).
+                # Option validations are present as a CodeList (with
+                #   CodeListItem children).
+                write_form_def(xml, dictionary)
+                write_item_group_def(xml, dictionary)
+                write_item_def(xml, dictionary)
+                write_code_list(xml, dictionary)
+              end
+            end
+          end
+
+          def write_form_def(xml, dictionary)
+            xml.FormDef(
+              OID: "Form.#{dictionary.model_name}",
+              Name: dictionary.model_name.capitalize,
+              Repeating: "No",
+              'redcap:FormName': dictionary.model_name
+            ) do
+              # Assume a single item group
+              xml.ItemGroupRef(
+                ItemGroupOID: "#{dictionary.model_name}.attributes",
+                Mandatory: "No"
+              ) do
+              end
+            end
+          end
+
+          def write_item_group_def(xml, dictionary)
+            xml.ItemGroupDef(
+              OID: "#{dictionary.model_name}.attributes",
+              Name: "#{dictionary.model_name.capitalize} Attributes",
+              Repeating: "No"
+            ) do
+              dictionary.attributes.keys.map do |attribute_name|
+                xml.ItemRef(
+                  ItemOID: "#{dictionary.model_name}.#{attribute_name}", # Does this need to be unique across all items?
+                  Mandatory: "No",
+                  'redcap:Variable': attribute_name # Does this need to be unique?
+                ) do
+                end
+              end
+            end
+          end
+
+          def write_item_def(xml, dictionary)
+            model_attributes = models.model(dictionary.model_name).template.attributes
+            dictionary.attributes.keys.map do |attribute_name|
+              attribute = model_attributes.attribute(attribute_name)
+              attribute_type = attribute.attribute_type
+              params = {
+                OID: "#{dictionary.model_name}.#{attribute_name}", # Does this need to be unique across all items?
+                Name: attribute_name,
+                DataType: data_type_map[attribute_type] || 'text',
+                'redcap:Variable': attribute_name,
+                'redcap:FieldType': redcap_field_type_map[attribute_type] || 'text',
+                Length: '999' # How could we infer shorter values?
+              }
+
+              params['redcap:TextValidationType'] = redcap_text_validation_map[attribute_type] if redcap_text_validation_map[attribute_type]
+              params['redcap:FieldNote'] = attribute.desc if attribute.desc
+              xml.ItemDef(params) do
+                xml.Question do
+                  xml.send('TranslatedText', attribute_name.capitalize)
+                end
+
+                if attribute.validation && Etna::Clients::Magma::AttributeValidationType::ARRAY == attribute.validation['type']
+                  xml.CodeListRef(
+                    CodeListOID: "#{dictionary.model_name}.#{attribute_name}.choices"
+                  ) do
+                  end
+                end
+              end
+            end
+          end
+
+          def write_code_list(xml, dictionary)
+            model_attributes = models.model(dictionary.model_name).template.attributes
+            dictionary.attributes.keys.map do |attribute_name|
+              attribute = model_attributes.attribute(attribute_name)
+              if attribute.validation && Etna::Clients::Magma::AttributeValidationType::ARRAY == attribute.validation['type']
+                xml.CodeList(
+                  OID: "#{dictionary.model_name}.#{attribute_name}.choices",
+                  Name: "#{attribute_name}",
+                  DataType: "text",
+                  'redcap:Variable': attribute_name
+                ) do
+                  attribute.validation['value'].map do |option|
+                    xml.CodeListItem(
+                      CodedValue: option
+                    ) do
+                      xml.Decode() do
+                        xml.send('TranslatedText', option)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etna/clients/magma/workflows/materialize_magma_record_files_workflow.rb

@@ -97,8 +97,9 @@ module Etna
 
           dest_file = File.join(dest_dir, metadata_file_name(record_name: record[template.identifier], record_model_name: template.name, ext: '.json'))
           filesystem.mkdir_p(File.dirname(dest_file))
-          filesystem.with_writeable(dest_file, "w") do |io|
-            io.write(record_to_serialize.to_json)
+          json = record_to_serialize.to_json
+          filesystem.with_writeable(dest_file, "w", size_hint: json.bytes.length) do |io|
+            io.write(json)
           end
         end
 

data/lib/etna/command.rb

@@ -39,6 +39,10 @@ module Etna
       def string_flags
         @string_flags ||= []
       end
+
+      def multi_flags
+        @multi_flags ||= []
+      end
     end
 
     def flag_as_parameter(flag)
@@ -69,6 +73,12 @@ module Etna
           else
             flags[arg_name] = args.shift
           end
+        elsif self.class.multi_flags.include?(next_arg)
+          if args.empty?
+            raise "flag #{next_arg} requires an argument"
+          else
+            (flags[arg_name] ||= []) << args.shift
+          end
         elsif !found_non_flag
           raise "#{program_name} does not recognize flag #{next_arg}"
         else

data/lib/etna/cwl.rb

@@ -0,0 +1,697 @@
+require 'yaml'
+
+module Etna
+  class Cwl
+    FIELD_LOADERS = {}
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def self.loader
+      Etna::Cwl::RecordLoader.new(self)
+    end
+
+    def self.as_json(obj)
+      if obj.is_a?(Cwl)
+        as_json(obj.instance_variable_get(:@attributes))
+      elsif obj.is_a?(Hash)
+        {}.tap do |result|
+          obj.each do |k, v|
+            result[k] = as_json(v)
+          end
+        end
+      elsif obj.is_a?(Array)
+        obj.map { |v| as_json(v) }
+      else
+        obj
+      end
+    end
+
+    def as_json
+      self.class.as_json(@attributes)
+    end
+
+    class Loader
+      def load(val)
+        raise "Unimplemented"
+      end
+
+      def optional
+        OptionalLoader.new(self)
+      end
+
+      def map(&block)
+        FunctorMapLoader.new(self, &block)
+      end
+
+      def as_mapped_array(id_key = nil, value_key = nil)
+        MapLoader.new(self.as_array, id_key, value_key)
+      end
+
+      def or(*alternatives)
+        UnionLoader.new(self, *alternatives)
+      end
+
+      def as_array
+        ArrayLoader.new(self)
+      end
+    end
+
+    class AnyLoader < Loader
+      def load(val)
+        val
+      end
+
+      ANY = AnyLoader.new
+    end
+
+    class PrimitiveLoader < Loader
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+
+      def load(val)
+        unless val.is_a?(@type)
+          raise "Unexpected val #{val.inspect} for #{@name} type"
+        end
+
+        val
+      end
+
+      def name
+        @name
+      end
+
+      def self.find_primitive_type_loader(type_name)
+        constants.each do |c|
+          c = const_get(c)
+          if c.is_a?(Loader)
+            return c if c.name == type_name
+          end
+        end
+      end
+
+      STRING = PrimitiveLoader.new('string', String)
+      INT = PrimitiveLoader.new('int', Integer)
+      LONG = PrimitiveLoader.new('long', Integer)
+      FLOAT = PrimitiveLoader.new('float', Float)
+      DOUBLE = PrimitiveLoader.new('double', Float)
+      NULL = PrimitiveLoader.new('null', NilClass)
+
+      class BooleanLoader < Loader
+        def name
+          'boolean'
+        end
+
+        def load(val)
+          raise "Invalid value #{val.inspect} for boolean" unless val.instance_of?(TrueClass) || val.instance_of?(FalseClass)
+          val
+        end
+      end
+
+      BOOLEAN = BooleanLoader.new
+    end
+
+    class SourceLoader < Loader
+      # Resolves a string of the forms "a-primary-identifier" or "step_name/output" into
+      #   [:primary_inputs, "a-primary-identifier"] or
+      #   ["step_name", "output"] respectively
+      def load(val)
+        parts = []
+
+        if val.is_a?(Symbol)
+          val = val.to_s
+        end
+
+        if val.is_a?(Array)
+          parts = PrimitiveLoader::STRING.as_array.load(val)
+        elsif val.is_a?(String)
+          parts = val.split('/', max = 2)
+        end
+
+        if parts.length == 1
+          return [:primary_inputs, parts[0]]
+        elsif parts.length == 2
+          return parts
+        end
+
+        raise "Unexpected value for source #{val.inspect}"
+      end
+    end
+
+    class StrictMapLoader < Loader
+      def initialize(items, keys)
+        @items = items
+        @keys = keys
+      end
+
+      def load(val)
+        if val.is_a?(Hash)
+          val.map do |k, v|
+            [@keys.load(k), @items.load(v)]
+          end.to_h
+        else
+          raise "Unexpected val #{val.inspect} for hash"
+        end
+      end
+    end
+
+    class MapLoader < Loader
+      def initialize(items, idKey = nil, valueKey = nil)
+        @items = items
+        @idKey = idKey
+        @valueKey = valueKey
+      end
+
+      def load(val)
+        if val.is_a?(Hash)
+          val = [].tap do |result|
+            errors = {}
+            val.keys.sort.each do |k|
+              begin
+                v = val[k]
+                if v.is_a?(Hash)
+                  v[@idKey] = k
+                else
+                  v = {@idKey => k, @valueKey => v}
+                end
+
+                result << v
+              rescue => e
+                errors[k] = e.to_s
+              end
+            end
+
+            unless errors.empty?
+              raise errors.map { |k, v| "#{k}: #{v}" }.join("\n")
+            end
+          end
+        end
+
+        @items.load(val)
+      end
+    end
+
+    class ArrayLoader < Loader
+      def initialize(items)
+        @items = items
+      end
+
+      def load(val)
+        unless val.is_a?(Array)
+          raise "Unexpected val #{val.inspect} for array"
+        end
+
+        [].tap do |result|
+          errors = []
+          val.each do |item|
+            begin
+              loaded = Cwl.load_item(item, UnionLoader.new(self, @items))
+              if loaded.is_a?(Array)
+                result.push(*loaded)
+              else
+                result << loaded
+              end
+            rescue => e
+              errors << e.to_s
+            end
+          end
+
+          unless errors.empty?
+            raise errors.join("\n")
+          end
+        end
+      end
+    end
+
+    class EnumLoader < Loader
+      def initialize(*options)
+        @options = options
+      end
+
+      def load(val)
+        if @options.include?(val)
+          return val
+        end
+
+        raise "Value #{val.inspect} does not belong to one of (#{@options.join(', ')})"
+      end
+
+      PRIMITIVE_TYPE = EnumLoader.new("null", "boolean", "int", "long", "float", "double", "string")
+      NOMINAL_TYPE = EnumLoader.new("File")
+    end
+
+    class OptionalLoader < Loader
+      def initialize(inner_loader)
+        @inner_loader = inner_loader
+      end
+
+      def load(val)
+        if val.nil?
+          return nil
+        end
+
+        @inner_loader.load(val)
+      end
+    end
+
+    class RecordLoader < Loader
+      def initialize(klass, field_loaders = nil)
+        @klass = klass
+        @field_loaders = field_loaders
+      end
+
+      def field_loaders
+        @field_loaders || @klass::FIELD_LOADERS
+      end
+
+      def load(val)
+        unless val.is_a?(Hash)
+          raise "Unexpected value #{val.inspect} for type #{@klass.name}"
+        end
+
+        errors = {}
+        @klass.new({}.tap do |result|
+          field_loaders.each do |field_sym, loader|
+            field_str = field_sym.to_s
+            begin
+              result[field_str] = loader.load(val[field_str])
+            rescue => e
+              errors[field_str] = e.to_s
+            end
+          end
+
+          unless errors.empty?
+            raise errors.map { |k, e| "#{k}: #{e}" }.join(',')
+          end
+        end)
+      end
+    end
+
+    class NeverLoader < Loader
+      def load(val)
+        raise "This feature is not supported"
+      end
+
+      UNSUPPORTED = NeverLoader.new.optional
+    end
+
+    class UnionLoader < Loader
+      def initialize(*alternatives)
+        @alternatives = alternatives
+      end
+
+      def load(val)
+        errors = []
+        @alternatives.each do |loader|
+          begin
+            return loader.load(val)
+          rescue => e
+            errors << e.to_s
+          end
+        end
+
+        raise errors.join(", ")
+      end
+    end
+
+    class ArrayType < Cwl
+      class InnerLoader < Loader
+        def load(val)
+          RecordLoader.new(ArrayType, {
+              type: EnumLoader.new("array"),
+              items: TypedDSLLoader::WITH_UNIONS_TYPE_LOADER,
+          }).load(val)
+        end
+      end
+
+      def type_loader
+        loader = RecordType::Field.type_loader(@attributes['items'])
+        return nil if loader.nil?
+        @type_loader ||= ArrayLoader.new(loader)
+      end
+    end
+
+    class EnumType < Cwl
+      class InnerLoader < Loader
+        def load(val)
+          RecordLoader.new(EnumType, {
+              type: EnumLoader.new("enum"),
+              symbols: PrimitiveLoader::STRING.as_array,
+          }).load(val)
+        end
+      end
+
+      def type_loader
+        @type_loader ||= EnumLoader.new(*@attributes['symbols'])
+      end
+    end
+
+    class RecordType < Cwl
+      class RecordTypeLoader
+        def load(val)
+          RecordLoader.new(RecordType, {
+              type: EnumLoader.new("record"),
+              fields: Field::FieldLoader.new.as_mapped_array('name', 'type')
+          }).load(val)
+        end
+      end
+
+      class Record
+        def self.new(h)
+          h
+        end
+      end
+
+      def type_loader
+        @type_loader ||= begin
+          record_class = Class.new(Record)
+          RecordLoader.new(record_class, @attributes['fields'].map do |field|
+            loader = Field.type_loader(field.type)
+            return nil if loader.nil?
+            [field.name.to_sym, loader]
+          end.to_h)
+        end
+      end
+
+      class Field < Cwl
+        class FieldLoader < Loader
+          def load(val)
+            RecordLoader.new(Field, {
+                name: PrimitiveLoader::STRING,
+                type: TypedDSLLoader::WITH_UNIONS_TYPE_LOADER,
+                doc: PrimitiveLoader::STRING.optional,
+            }).load(val)
+          end
+        end
+
+        def name
+          @attributes['name']
+        end
+
+        def type
+          @attributes['type']
+        end
+
+        def type_loader
+          self.class.type_loader(self.type)
+        end
+
+        def self.type_loader(type)
+          case type
+          when Array
+            type_loaders = type.map { |t| Field.type_loader(t) }
+            return nil if type_loaders.any?(&:nil?)
+            UnionLoader.new(*type_loaders)
+          when EnumType
+            type.type_loader
+          when RecordType
+            type.type_loader
+          when ArrayType
+            type.type_loader
+          when String
+            PrimitiveLoader.find_primitive_type_loader(type)
+          else
+            raise "Could not determine loader for type #{type.inspect}"
+          end
+        end
+      end
+    end
+
+    class FunctorMapLoader < Loader
+      def initialize(inner, &block)
+        @block = block
+        @inner = inner
+      end
+
+      def load(val)
+        @block.call(@inner.load(val))
+      end
+    end
+
+    # Prepares a unique set of structured nominal types for an inner
+    # loading of types
+    class TypedDSLLoader < Loader
+      def initialize(inner)
+        @inner = inner
+      end
+
+      REGEX = /^([^\[?]+)(\[\])?(\?)?$/
+
+      def resolve(val)
+        m = REGEX.match(val)
+
+        unless m.nil?
+          type = m[1]
+          unless m[2].nil?
+            type = {'type' => 'array', 'items' => type}
+          end
+          unless m[3].nil?
+            type = ["null", type]
+          end
+
+          return type
+        end
+
+        val
+      end
+
+      def load(val)
+        if val.is_a?(Array)
+          @inner.load(val.map do |item|
+            item.is_a?(String) ? resolve(item) : item
+          end)
+        elsif val.is_a?(String)
+          @inner.load(resolve(val))
+        else
+          @inner.load(val)
+        end
+      end
+
+      OUTER_TYPE_LOADER = TypedDSLLoader.new(
+          UnionLoader.new(
+              RecordType::RecordTypeLoader.new,
+              ArrayType::InnerLoader.new,
+              EnumType::InnerLoader.new,
+              EnumLoader::PRIMITIVE_TYPE,
+              EnumLoader::NOMINAL_TYPE,
+          )
+      )
+
+      WITH_UNIONS_TYPE_LOADER = TypedDSLLoader.new(
+          UnionLoader.new(
+              OUTER_TYPE_LOADER,
+              ArrayLoader.new(OUTER_TYPE_LOADER),
+          )
+      )
+    end
+
+    def self.load_item(val, field_type)
+      if val.is_a?(Hash)
+        if val.include?("$import")
+          raise "$import expressions are not yet supported"
+        elsif val.include?("$include")
+          raise "$include expressions are not yet supported"
+        end
+      end
+
+      return field_type.load(val)
+    end
+
+    class InputParameter < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING.optional,
+          label: PrimitiveLoader::STRING.optional,
+          secondaryFiles: NeverLoader::UNSUPPORTED,
+          streamable: NeverLoader::UNSUPPORTED,
+          loadContents: NeverLoader::UNSUPPORTED,
+          loadListing: NeverLoader::UNSUPPORTED,
+          valueFrom: NeverLoader::UNSUPPORTED,
+          doc: PrimitiveLoader::STRING.optional,
+
+          type: TypedDSLLoader::WITH_UNIONS_TYPE_LOADER,
+          default: AnyLoader::ANY.optional,
+          format: PrimitiveLoader::STRING.optional,
+      }
+
+      def default
+        default = @attributes['default']
+        return nil unless default
+        RecordType::Field.type_loader(@attributes['type'])&.load(default)
+      end
+    end
+
+    class OutputParameter < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING.optional,
+          label: PrimitiveLoader::STRING.optional,
+          secondaryFiles: NeverLoader::UNSUPPORTED,
+          streamable: NeverLoader::UNSUPPORTED,
+          doc: PrimitiveLoader::STRING.optional,
+
+          outputBinding: NeverLoader::UNSUPPORTED,
+          type: TypedDSLLoader::WITH_UNIONS_TYPE_LOADER,
+          format: PrimitiveLoader::STRING.optional,
+      }
+    end
+
+    class WorkflowOutputParameter < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING,
+          label: PrimitiveLoader::STRING.optional,
+          secondaryFiles: NeverLoader::UNSUPPORTED,
+          streamable: NeverLoader::UNSUPPORTED,
+          linkMerge: NeverLoader::UNSUPPORTED,
+          pickValue: NeverLoader::UNSUPPORTED,
+          doc: PrimitiveLoader::STRING.optional,
+
+          outputSource: SourceLoader.new,
+          type: TypedDSLLoader::WITH_UNIONS_TYPE_LOADER,
+          format: PrimitiveLoader::STRING.optional,
+      }
+
+      def outputSource
+        @attributes['outputSource']
+      end
+
+      def id
+        @attributes['id']
+      end
+    end
+
+    class WorkflowInputParameter < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING,
+          label: PrimitiveLoader::STRING.optional,
+          secondaryFiles: NeverLoader::UNSUPPORTED,
+          streamable: NeverLoader::UNSUPPORTED,
+          loadContents: NeverLoader::UNSUPPORTED,
+          loadListing: NeverLoader::UNSUPPORTED,
+          doc: PrimitiveLoader::STRING.optional,
+          inputBinding: NeverLoader::UNSUPPORTED,
+
+          default: AnyLoader::ANY,
+          type: TypedDSLLoader::WITH_UNIONS_TYPE_LOADER,
+          format: PrimitiveLoader::STRING.optional,
+      }
+
+      def id
+        @attributes['id']
+      end
+
+      def default
+        @attributes['default']
+      end
+    end
+
+    class StepOutput < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING,
+      }
+
+      def id
+        @attributes['id']
+      end
+    end
+
+
+    class StepInput < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING.optional,
+          source: SourceLoader.new.optional,
+          label: PrimitiveLoader::STRING.optional,
+          linkMerge: NeverLoader::UNSUPPORTED,
+          pickValue: NeverLoader::UNSUPPORTED,
+          loadContents: NeverLoader::UNSUPPORTED,
+          loadListing: NeverLoader::UNSUPPORTED,
+          valueFrom: NeverLoader::UNSUPPORTED,
+          default: AnyLoader::ANY.optional,
+      }
+
+      def id
+        @attributes['id']
+      end
+
+      def source
+        @attributes['source']
+      end
+    end
+
+    class Operation < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING.optional,
+          label: PrimitiveLoader::STRING.optional,
+          doc: PrimitiveLoader::STRING.optional,
+          requirements: NeverLoader::UNSUPPORTED,
+          hints: NeverLoader::UNSUPPORTED,
+          cwlVersion: EnumLoader.new("v1.0", "v1.1", "v1.2").optional,
+          intent: NeverLoader::UNSUPPORTED,
+          class: EnumLoader.new("Operation"),
+          inputs: InputParameter.loader.as_mapped_array('id', 'type'),
+          outputs: OutputParameter.loader.as_mapped_array('id', 'type'),
+      }
+
+      def id
+        @attributes['id']
+      end
+    end
+
+    class Step < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING.optional,
+          label: PrimitiveLoader::STRING.optional,
+          doc: PrimitiveLoader::STRING.optional,
+          in: StepInput.loader.as_mapped_array('id', 'source'),
+          out: StepOutput.loader.or(PrimitiveLoader::STRING.map { |id| StepOutput.loader.load({'id' => id}) }).as_array,
+          requirements: NeverLoader::UNSUPPORTED,
+          hints: NeverLoader::UNSUPPORTED,
+          run: PrimitiveLoader::STRING.map { |id| Operation.loader.load({'id' => id, 'class' => 'Operation', 'inputs' => [], 'outputs' => []}) }.or(Operation.loader),
+          when: NeverLoader::UNSUPPORTED,
+          scatter: NeverLoader::UNSUPPORTED,
+          scatterMethod: NeverLoader::UNSUPPORTED,
+      }
+
+      def id
+        @attributes['id']
+      end
+
+      def in
+        @attributes['in']
+      end
+
+      def out
+        @attributes['out']
+      end
+    end
+
+    class Workflow < Cwl
+      FIELD_LOADERS = {
+          id: PrimitiveLoader::STRING.optional,
+          label: PrimitiveLoader::STRING.optional,
+          doc: PrimitiveLoader::STRING.optional,
+          requirements: NeverLoader::UNSUPPORTED,
+          hints: NeverLoader::UNSUPPORTED,
+          intent: NeverLoader::UNSUPPORTED,
+          class: EnumLoader.new("Workflow"),
+          cwlVersion: EnumLoader.new("v1.0", "v1.1", "v1.2"),
+          inputs: WorkflowInputParameter.loader.as_mapped_array('id', 'type'),
+          outputs: WorkflowOutputParameter.loader.as_mapped_array('id', 'type'),
+          steps: Step.loader.as_mapped_array('id', 'source')
+      }
+
+      def inputs
+        @attributes['inputs']
+      end
+
+      def outputs
+        @attributes['outputs']
+      end
+
+      def steps
+        @attributes['steps']
+      end
+    end
+  end
+end