illusional
diff --git a/‎cwlgen/requirements.py
Lines changed: 26 additions & 7 deletions b/‎cwlgen/requirements.py
Lines changed: 26 additions & 7 deletions
@@ -28,7 +28,7 @@ def parse_dict(cls, d):
 
         c = d["class"]
         requirements = [
-            InlineJavascriptReq, SchemaDefRequirement, SoftwareRequirement, InitialWorkDirRequirement,
+            InlineJavascriptRequirement, SchemaDefRequirement, SoftwareRequirement, InitialWorkDirRequirement,
             SubworkflowFeatureRequirement, ScatterFeatureRequirement, MultipleInputFeatureRequirement,
             StepInputExpressionRequirement, DockerRequirement, EnvVarRequirement, ShellCommandRequirement,
             ResourceRequirement
@@ -41,7 +41,7 @@ def parse_dict(cls, d):
         return None
 
 
-class InlineJavascriptReq(Requirement):
+class InlineJavascriptRequirement(Requirement):
     """
     Indicates that the workflow platform must support inline Javascript expressions.
     If this requirement is not present, the workflow platform must not perform expression interpolatation.
@@ -102,7 +102,7 @@ class InputRecordField(Serializable):
             """
             Documentation: https://www.commonwl.org/v1.0/Workflow.html#InputRecordField
             """
-            def __init__(self, name, input_type, doc=None, input_binding=None, label=None):
+            def __init__(self, name, type, doc=None, input_binding=None, label=None):
                 """
                 :param name:
                 :param input_type:
@@ -114,7 +114,7 @@ def __init__(self, name, input_type, doc=None, input_binding=None, label=None):
                 :param label:
                 """
                 self.name = name
-                self.type = parse_type(input_type, requires_type=True)
+                self.type = parse_type(type, requires_type=True)
                 self.doc = doc
                 self.inputBinding = input_binding
                 self.label = label
@@ -124,8 +124,16 @@ def get_dict(self):
                 d["type"] = get_type_dict(self.type)
                 return d
 
+            # def parse_dict(cls, d):
+            #     d["input_type"] = "string"
+            #     ret = super(SchemaDefRequirement.InputRecordSchema.InputRecordField, cls).parse_dict(d)
+            #     ret.type =
+
+
+        # ignore_fields_on_parse = "type"
         parse_types = {
-            "fields": [InputRecordField]
+            "fields": [InputRecordField],
+            "inputBinding": [CommandLineBinding]
         }
 
     class InputEnumSchema(Serializable):
@@ -183,11 +191,22 @@ def parse_dict(cls, d):
                 return None
             return cls.parse_dict_generic(cls, d)
 
+        parse_types = {
+            # Defined below because we need to have declared the class before we can use it
+        }
+
     parse_types = {
-        "fields": [InputRecordSchema, InputEnumSchema, InputArraySchema]
+        "types": [InputRecordSchema, InputEnumSchema, InputArraySchema],
     }
 
 
+# declare this here, because inside the InputArraySchema we haven't fully defined the schemas
+SchemaDefRequirement.InputArraySchema.parse_types = {
+    "items": [SchemaDefRequirement.InputRecordSchema, SchemaDefRequirement.InputEnumSchema,
+              SchemaDefRequirement.InputArraySchema, str]
+}
+
+
 class SoftwareRequirement(Requirement):
     """
     A list of software packages that should be configured in the environment of the defined process.
@@ -214,7 +233,7 @@ def __init__(self, package, version=None, specs=None):
             self.specs = specs
 
     parse_types = {
-        "package": [SoftwarePackage]
+        "packages": [SoftwarePackage]
     }