CLI                     Ant                     Maven                   Description               Argument Type       

--edit-copyright        <rat:report             <editCopyright>         The copyright message to  String              
                          editCopyright =                                 use in the license                          
                          'text'/>                                        headers. Usually in                         
                                                                          the form of "Copyright                      
                                                                          2008 Foo".  Only valid                      
                                                                          with --edit-license                         

--edit-overwrite        <rat:report             <editOverwrite>         Forces any changes in     -- none --          
                          editOverwrite =                                 files to be written                         
                          'text'/>                                        directly to the source                      
                                                                          files (i.e. new files                       
                                                                          are not created). Only                      
                                                                          valid with                                  
                                                                          --edit-license                              

--edit-license          <rat:report             <editLicense>           Add the default license   -- none --          
                          editLicense =                                   header to any file                          
                          'text'/>                                        with an unknown                             
                                                                          license that is not in                      
                                                                          the exclusion list. By                      
                                                                          default new files will                      
                                                                          be created with the                         
                                                                          license header, to                          
                                                                          force the modification                      
                                                                          of existing files use                       
                                                                          the --edit-overwrite                        
                                                                          option.                                     

--config                <rat:report>            <config>                File names for system     File                
                                                                          configuration.                              
                          <config>text</config                                                                        
                          >                                                                                           
                        </rat:report>                                                                                 

--configuration-no-def  <rat:report             <configurationNoDefaul  Ignore default            -- none --          
  aults                   configurationNoDefau    ts>                     configuration.                              
                          lts = 'text'/>                                                                              

--licenses-approved     <rat:report>            <licensesApproved>      The approved License      LicenseID           
                                                                          IDs. These licenses                         
                          <licensesApproved>te                            will be added to the                        
                          xt</licensesApproved                            list of approved                            
                          >                                               licenses.                                   
                        </rat:report>                                                                                 

--licenses-approved-fi  <rat:report             <licensesApprovedFile>  Name of file containing   File                
  le                      licensesApprovedFile                            the approved License                        
                          = 'text'/>                                      IDs.                                        

--license-families-app  <rat:report>            <licenseFamiliesApprov  The approved License      FamilyID            
  roved                                           ed>                     Family IDs. These                           
                          <licenseFamiliesAppr                            licenses families will                      
                          oved>text</licenseFa                            be added to the list                        
                          miliesApproved>                                 of approved licenses                        
                        </rat:report>                                     families.                                   

--license-families-app  <rat:report             <licenseFamiliesApprov  Name of file containing   File                
  roved-file              licenseFamiliesAppro    edFile>                 the approved family                         
                          vedFile = 'text'/>                              IDs.                                        

--licenses-denied       <rat:report>            <licensesDenied>        The denied License IDs.   LicenseID           
                                                                          These licenses will be                      
                          <licensesDenied>text                            removed from the list                       
                          </licensesDenied>                               of approved licenses.                       
                        </rat:report>                                     Once licenses are                           
                                                                          removed they can not                        
                                                                          be added back.                              

--licenses-denied-file  <rat:report             <licensesDeniedFile>    Name of file containing   File                
                          licensesDeniedFile =                            the denied license                          
                          'text'/>                                        IDs.                                        

--license-families-den  <rat:report>            <licenseFamiliesDenied  The denied License        FamilyID            
  ied                                             >                       family IDs. These                           
                          <licenseFamiliesDeni                            license families will                       
                          ed>text</licenseFami                            be removed from the                         
                          liesDenied>                                     list of approved                            
                        </rat:report>                                     licenses.                                   

--license-families-den  <rat:report             <licenseFamiliesDenied  Name of file containing   File                
  ied-file                licenseFamiliesDenie    File>                   the denied license                          
                          dFile = 'text'/>                                IDs.                                        

--input-exclude         <rat:report>            <inputExclude>          Excludes files matching   Expression          
                                                                          <Expression>.                               
                          <inputExclude>text</                                                                        
                          inputExclude>                                                                               
                        </rat:report>                                                                                 

--input-exclude-file    <rat:report             <inputExcludeFile>      Reads <Expression>        File                
                          inputExcludeFile =                              entries from a file.                        
                          'text'/>                                        Entries will be                             
                                                                          excluded from                               
                                                                          processing.                                 

--input-exclude-std     <rat:report>            <inputExcludeStd>       Excludes files defined    StandardCollection  
                                                                          in standard                                 
                          <inputExcludeStd>tex                            collections based on                        
                          t</inputExcludeStd>                             commonly occurring                          
                        </rat:report>                                     groups.                                     

--input-include         <rat:report>            <inputInclude>          Includes files matching   Expression          
                                                                          <Expression>. Will                          
                          <inputInclude>text</                            override excluded                           
                          inputInclude>                                   files.                                      
                        </rat:report>                                                                                 

--input-include-file    <rat:report             <inputIncludeFile>      Reads <Expression>        File                
                          inputIncludeFile =                              entries from a file.                        
                          'text'/>                                        Entries will override                       
                                                                          excluded files.                             

--input-include-std     <rat:report>            <inputIncludeStd>       Includes files defined    StandardCollection  
                                                                          in standard                                 
                          <inputIncludeStd>tex                            collections based on                        
                          t</inputIncludeStd>                             commonly occurring                          
                        </rat:report>                                     groups. Will override                       
                                                                          excluded files.                             

--input-exclude-parsed  <rat:report>            <inputExcludeParsedScm  Parse SCM based           StandardCollection  
  -scm                                            >                       exclusion files to                          
                          <inputExcludeParsedS                            exclude specified                           
                          cm>text</inputExclud                            files and directories.                      
                          eParsedScm>                                                                                 
                        </rat:report>                                                                                 

--output-style          <rat:report             <outputStyle>           XSLT stylesheet to use    StyleSheet          
                          outputStyle =                                   when creating the                           
                          'text'/>                                        report. Either an                           
                                                                          external xsl file may                       
                                                                          be specified or one of                      
                                                                          the internal named                          
                                                                          sheets.                                     

--output-licenses       <rat:report             <outputLicenses>        List the defined          LicenseFilter       
                          outputLicenses =                                licenses.                                   
                          'text'/>                                                                                    

--output-families       <rat:report             <outputFamilies>        List the defined license  LicenseFilter       
                          outputFamilies =                                families.                                   
                          'text'/>                                                                                    

--log-level             -- not supported --     -- not supported --     sets the log level.       LogLevel            

--dry-run               <rat:report dryRun =    <dryRun>                If set do not update the  -- none --          
                          'text'/>                                        files but generate the                      
                                                                          reports.                                    

--output-file           <rat:report outputFile  <outputFile>            Define the output file    File                
                          = 'text'/>                                      where to write a                            
                                                                          report to.                                  

--output-archive        <rat:report             <outputArchive>         Specifies the level of    ProcessingType      
                          outputArchive =                                 detail in ARCHIVE file                      
                          'text'/>                                        reporting.                                  

--output-standard       <rat:report             <outputStandard>        Specifies the level of    ProcessingType      
                          outputStandard =                                detail in STANDARD                          
                          'text'/>                                        file reporting.                             

--help-licenses         <rat:report             <helpLicenses>          Print information about   -- none --          
                          helpLicenses =                                  registered licenses.                        
                          'text'/>                                                                                    

--help                  -- not supported --     -- not supported --     Print help for the RAT    -- none --          
                                                                          command line interface                      
                                                                          and exit.