hoReverse allows you to

• Import
  • Import Tutorial
• Roundtrip
• Export
  • Export Tutorial
• Info of ReqIF file or Folder
• Helpers, Validate ReqIF

according to ReqIF into EA packages. It supports *.reqif and compressed *.reqifz.

I've tested it with DOORS, ReqIF Studio and stuff from ReqIF.academy

The ReqIF concept also allows to exchange information Roundtrip with test and can establish be-directional traceability.

These principles cover Import, Roundtrip, Export.

• EA Package An EA package is a ReqIF Specification. In Doors you would name it a Formal Module
• EA Elements are the requirements. Usually, you would use nested Elements to denote the ReqIF hierarchical structure
  • EA standard Properties
    • Name: ReqIF.Name, the name or short text of the requirements
    • Notes: ReqIF.Text, the ReqIF Text in EA specification/note format
    • Linked Document: ReqIF.Text, the reqIF Text as *.docx with images and embedded files)
    • Alias: Possible mapping to ReqIF attribute via Import Specification
    • Multiplicity: The ReqIF identifier
  • Tagged Values for ReqIF Attributes
    • EA Tagged Value Types are used for Enumerations (single-value: Enumeration, multi-value: CheckList)
    • If no Tagged Value type exists the content is XHTML formatted
• Trash Package: A package to move deleted Requirements into to handle existing dependencies and to remove them later

hoReverse supports ReqIF RoundTrip/Workflow of ReqIF requirements. This includes bi-directional traceability according to SPICE by sending the EA-GUID of the EA model element to your requirement tool.

The typical process:

• Requirement Tool: Initial export
• EA: Initial import
• EA: Update the EA Tagged Values which are intended for roundtrip
• EA: Export to your Requirement Tool (ReqIF compatible)
• Requirement Tool: Roundtrip import

• RoundTrip/Workflow
• Import
  • ReqIF Import
  • Structured XML
  • DOORS *.csv import

• ReqIF (Version 1.0, 1.1, 1.2)
• RoundTrip/Workflow
• Import specification to easily re-run
  • Specify import
  • Specify export / roundtrip
  • Make groups to import/export a bulk of requirements with one click
• Structured/nested requirements
• Images and formatting in EA 'Linked Docucuments'
• Attributes
  • per Requirement
  • per Module
  • additional hoReverse extensions
• Traceability imported between ReqIF modules
• Specify what you see in EA
  • Name (which ReqIF attributes it's constructed of)
  • Alias (which ReqIF attributes it's constructed of)
  • LinkedDocument/RTF (which ReqIF attributes it's constructed of)
  • Notes (which ReqIF attribute it's constructed of)
  • GUID of package (always import in the specified package)
  • Deleted folder to see deleted requirements
  • The EA object to create (EA Object Type like 'Requirment' and the ≪Stereotype≫)
  • The ReqIF attributes as EA Tagged Values
  • Traceability stereotype for imported traceability
• Embedded ReqIF files are stored with the EA Requirement as EA Files.
  • DOORS: *.ole files and if .pdf/.wmf converted to their type
  • Search to find embedded files
• Add-In Search to show/search nested elements

1. User: Export Requirements from your Requirement Tool in ReqIF format
2. User: EA Menu Do, Import *.csv, ReqIF, Select the import from the list
3. EA: Imports the requirements in the specified EA-Packages (see Example)

1. User: EA Menu File, Settings: ReqIF,..
2. EA: Opens Setting.json to edit the import specifications
3. User: Goto section "Importer"
4. User: Edit the import specifications
5. User: Restart EA

hoReverse uses the following EA items to store atrributes:

• Name (you can define which ReqIF attributes are combined as Name)
  • For DOORS I usually use: Id + Name, limited to 60 characters without control character
  • '1284 My Requirement with ID=1284'
• Alias (you can define which ReqIF attributes are combined as Alias)
  • For DOORS I usually use the DOORS ID
• Linked Document to show formatting and graphics
  • Usually Text or Heading, you can define which ReqIF attributes are combined as Alias
• Motes (you can define which ReqIF attribute is used as Notes)
• Multiplicity (50 character long which holds the unique identifier)
• TaggedValues
  • The ReqIF attributes
• EA Property status when newly created

See Import Specification

see

hoReverse stores the module attributes as Tagged Values. See

hoReverse reads the ReqIF imported traceabilities and:

• Makes/maintain dependencies between the requirements
  • Uses the configured <<Stereotype>> for the Dependency Connector

You may use an EA Relationship Matrix to visualize imported dependencies/traceabilities:

Because EA handles sorting in Matrixes by itself, I see no good way to reflect the nested order in the matrix. Also using Searches doesn't change it.

A workaround is to use EA ModelViews (Artifact) and the (modified) EA Add-In Search 'hoReverse.AddInSearchObjectsNested'.

hoReverse and also hoTools contains an Add-In Search and a Service to show nested elements like Requirements.

For details see the description in hoTools: Show nested Requirements. hoReverse supports the same.

hoReverse visualizes most ReqIF columns as EA Tagged Values of type string. For Enumerations:

• single value or
• multi value

hoReverse uses EA Tagged Value Types for easy visualization and editing. It's possible to define module specifiy prefixes for Tagged Values.

hoReverse generates the required TaggedValue Types.

hoReverse converts the ReqIF Attribute type into EA Tagged Value Types / SPARX EA TaggedValue Types:

Standard for all not explicitly supported types. hoReverse tries to convert XHTML into a meaningful string.

hoReverse uses Tagged Value Types to ease visualization and editing of special types like Enumeration.

See: Settings Import, Roundtrip, Export

The import specification specifies:

• Import
• Roundtrip
• Grouping of imports/roundtrips
• Mapping of columns betweem EA and the Requirement Tool.

You can edit the Import Specification in Settings.json , chapter "Importer".

  // Importer settings to import ReqIf, DoorsCsv, DoorsReqIF, xmlStruct into EA packages:
  // - Specify import rules to import a type of file into one or more EA Packages
  // - Specify roundtrip for ReqIF
  // - see class: 'FileImportSettingsItem'
  //
  // Rules: 
  // - A File path may be written with either '\', or '/'
  //
  // Settings:
  // - Name:            The name in the EA menu to use this particular specification  
  // - Description:     Further description visualied as tooltip in the menu description
  // - ListNo:          hoReverse imports all specifications with the same ListNo with one click in the EA Menu 
  // - InputFile:       The Path of the file to import, you have to use the extensions (*.csv, *.reqif,, *.reqifz, *.xml) depending on the particular 'ImportType'
  // - PackageGuidList: The list of Guids for the packages to import into or export from. The compressed *.reqifz format allows/demands one GUID for each imported/exported 'Module'. The other file types only support one GUID/package.
  //                    ["{F199A750-C7BF-4625-A95D-F4C1AF8E4900}","{157D337C-13BB-4fc0-AA10-79F0A7587C99}" ],
  // - PrefixTaggedValueTypeList
  //                    List of prefixes to use for each ReqIF module like ["ArchA_", "ArchB_"]
  // - ObjectType:      The valid EA ObjectType to create for each imported row (e.g. 'Requirement').
  // - Stereotype:      The EA Stereotype to use for each imported row (e.g. 'Functional Requirement')
  // - ImportType:      'DoorsCsv'   = Doors *.csv import format for requirements (tested with Doors 9.6)
  //                    'DoorsReqIf' = DOORS reqif format (*.reqif, *.reqifz)
  //                    'ReqIf'      = ReqIf format (*.reqif, *.reqifz)
  //                    'XmlStruct'  = Structured xml for requirements, tests or so
  // - StatusNew:       The EA status property to set for new EA element
  // - StatusChanged:   The EA status property to set for changed EA elements (only supported for ImportType 'DoorsCsv')
  // - RtfNameList      List of ReqIF attribute names to put in EA Linked Document (support of graphics)
  //                    ["Object Text",],
  // - AttrNameList     List of ReqIF attribute names to put in EA Name
  //                    ["ReqIF.ForeignID", "ReqIF.Chaptername", "ReqIF.Text"],
  // - AttrNotes        The attribute name to import into the EA property 'Note', e.g. "Object Text"
  // - AliasList        List of attribute names to import into the EA property 'Alias', e.g. ["RequirementID"] or ["ReqIF.ForeignID"]
  // - WriteAttrNameList List of attribue names to export back to the ReqIF file (Implementation of ReqIF Workflow). Only Tagged values of string or xhtml are allowed.
  //                    You can use variables to autfill fields. ["MyReferenceToEA=EA.GUID"]
  //                    hoReverse supports the following autofill fields:
  //                    - EA.GUID
  //                    - EA.Created
  //                    - EA.Modified
  //                    - EA.Name
  //                    - EA.Version
  //                    - EA.Status
  //                    - EA.Stereotype
  //                    - EA.Type
  //                    - EA.Author
  //                    - EA.Phase
  // - EmbeddedFileStorageDictionary
  //                    Dictionary/Folder of ReqIF embedded files to store. If blank or empty then don't store 
  // - IdList"          Only "XmlStruct":
  //                    List of attribute names to use for ImportType "XmlStruct" as unique ID, e.g.  ["ForeignID"]  
  "Importer":
  [

• Settings Import, Roundtrip, Export

Tested with ReqIF Studio and DOORS.

{
          "Name"            :  "13. Roundtrip 'RoundTrip_Arch.reqifz'",
          "Description"     :  "Roundtrip with DOORS",
          "ListNo"          :  "13",
          "InputFile"       :  "c:/hoData/Projects/00Current/Veoneer/ReqIF/RoundTrip_Arch.reqifz" ,
          "ExportFile"      :  "c:/hoData/Projects/00Current/Veoneer/ReqIF/RoundTrip_ArchExport.reqifz" ,
          "PackageGuidList" :  ["{F199A750-C7BF-4625-A95D-F4C1AF8E4900}","{157D337C-13BB-4fc0-AA10-79F0A7587C99}" ],
          "PrefixTaggedValueTypeList": ["ArchA_", "ArchB_"],
          "ObjectType"      :  "Requirement",
          "Stereotype"      :  "",
          "ImportType"      :  "DoorsReqIF",
          "StatusNew"       :  "Proposed",
          "StatusChanged"   :  "None",
          "RtfNameList"     :  ["ReqIF.Text"],
          "AttrNameList"    :  ["ReqIF.ForeignID", "ReqIF.Chaptername", "ReqIF.Text"],
          "AttrNotes"       :  "ReqIF.Text",
          "AliasList"       :  ["ReqIF.ForeignID"],
          "EmbeddedFileStorageDictionary" : "c:/Temp/ReqIF/Store/12/",
          "WriteAttrNameList": [ "_ArchBlockId=EA.GUID", "_ArchitectureStatComment","_ArchitectureStatus","_SortingCrit"]

      }

Select the package with requirements and run the Search. It shows you all Requirements with stored embedded files.

select o.ea_guid as CLASSGUID, o.object_type as CLASSTYPE, pkg.name As[Package], o.name As [Requirement], f.FileName as [File Name] 
         from (t_object o
         inner join t_objectfiles f on o.object_id = f.object_id)
		 inner join t_package pkg on o.package_id = pkg.package_id
where pkg.package_id in (#Branch#)
order by 3,4

• ReqIF#, open-source C# Library to read/write ReqIF via .NET
• ReqIF.academy
• OpenMCDF

• Tutorial Export
• Tutorial Import
• Eclipse ProR
• Eclipse ProR
• Import & Export
• OMG Specification
• Show nested Requirements
• ReqIF.academy
• ReqIF Helpers
• ReqIF Validate
• ReqIF Information of a file or folder with *.reqif or *.reqifz
• ReqIF in DOORS
• ReqIF Studio, the free ReqIF Editor & a lot more
• ReqIF Test data (Eclipse)
• Settings Import, Roundtrip, Export
• Tagged Values

• .reqif for a single ReqIF XML file
• .reqifz for a ZIP achieve containing ReqIF files and additional files

• Attribute (ReqIF) With Attributes a Requirement may contain additional information stored in the Attributes. In EA this are Tagged Values.
• EA Tagged Values are a UML/SysML compliant method to provide additional properties to UML/SysML elements and connectors. Here we use it to define arbitrary ReqIF Attributes to exchange with other tools.
• GUID Universally unique identifier used by EA to uniquely identify an object
• MCDF Microsoft Compound Document Format (used by DOORS embedded files)
• Package The Package which contains the requirements. In terms of ReqIF its the Specification or in DOORS the Module.
• ReqIF Requirements Interchange Format
• ReqIF Roundtrip, often called ReqIF Workflow. The Standard how to exchange ReqIF requirements between two partners
• ReqIF Standard of the OMG to exchange requirements between different tools, see OMG Specification
• ReqIF Workflow: ReqIF workflow specifies how to exchange requirements between tools. Often called Roundtrip
• ReqIF Tool: A tool that imports/exports ReqIF compliant XML documents
• Requirements authoring tool: A tool to create and modifying requirements
• Specification In ReqIF the container which contains the requirements. In DOORS it's named 'Module'.
• SPICE Process Reference Model to assess process maturity.
• Tagged Values UML/EA measure to add values to a classifier/requirement. For enumerations EA needs Tagged Value Types (Enum or Checklist).
• Traceability