Top Level Namespace

Defined Under Namespace

Constant Summary collapse

OR_MAPPING =

%w[jpox,jpa]

OR_MAPPING_ALIASES =

{ "jdo" => "jpox", "jpa" => "hibernate" ,"none" => "none"}

DB_TYPE_DISCRIMINATOR =

%w[:default,:int]

DB_TYPE_DISCRIMINATOR_ALIASES =

{"int"=>:int,"default"=>:default}

Instance Method Summary collapse

#removeVersionInARGV ⇒ Object

Rubygems allow a specific script version to be passed on command line.
#runJavaFrontEnd(startupFile) ⇒ Object

run java generator command line front end startupFile is the name of the calling script.
#say(x) ⇒ Object
#step_bpm(model) ⇒ Object

Process bpm enhancement.
#step_generate_crank(model) ⇒ Object
#step_generate_flex(model) ⇒ Object

generate flex artefacts.
#step_generate_java(model) ⇒ Object

write java files to disk.
#step_generate_misc(model) ⇒ Object

generate misc.
#step_generate_struts(model) ⇒ Object

write struts files to disk.
#step_generate_tests(model) ⇒ Object

process tests loaded from protege/2000 and generate test artefacts.
#step_generateKb(model) ⇒ Object

Generate protege 2000 knowlege base.
#step_load(model) ⇒ Object

load meta-model(s) and model(s).
#step_transform10(model) ⇒ Object

Enhance UML model.
#step_transform20(model) ⇒ Object
#step_transform30(model) ⇒ Object
#step_transform40(model) ⇒ Object

Instance Method Details

#removeVersionInARGV ⇒ `Object`

Rubygems allow a specific script version to be passed on command line. Version is passed as a first parameter like : 1.0.1

For testing purposes, this script may be called directly (not through gem). We have to remove the version number which was not removed by gem.

# File 'lib/ontomde-java-frontend/command.rb', line 53

def  removeVersionInARGV  
	return if ARGV.empty?
	return unless ARGV[0]=~/^_[.0-9]*_$/
	puts "** WARNING: command line parameter #{ARGV[0]} ignored.\n"
	ARGV.delete_at(0)
end

#runJavaFrontEnd(startupFile) ⇒ `Object`

run java generator command line front end startupFile is the name of the calling script.

# File 'lib/ontomde-java-frontend/command.rb', line 62

def runJavaFrontEnd(startupFile)
  puts "Starting ontomde v. #{Ontomde::Java::Frontend::VERSION}"

  removeVersionInARGV() 

  h3="## "
  options = {}
  options[:testRelativeDir]="src/test/java"
  options[:jspUseXmdaTaglib]=true
  options[:backTrace] = false
  options[:selfTestAndExit] = false
  options[:verbose]=false
  options[:targetDir]="."
  options[:javaRelativeDir]="./src/java/"
  options[:flexRelativeDir]="webapp/src/main/flex/"
  options[:webResourcesDir]=options[:javaRelativeDir]
  options[:flex]=false
  options[:mysql]=false
  options[:nt]=[]
  options[:load]=[]
  options[:dryRun]=false
  options[:withAutoImplementProperty]=false
  options[:withEnumAsString]=false
  options[:withAutoImplementOperation]=false
  options[:withMultipleInheritance]=true
  options[:strutsActionFormPackage]="struts"
  options[:enumAssignableSubPackage]="assignable"
  options[:withEnumAssignable]=true
  options[:withGenerateMethodForm]=false
  options[:makeCompositionBiNavigable]=false
  options[:salvage]=false
  options[:useUnzip]=false
  options[:messageCheck]=true
  options[:struts]=false
  options[:crank]=false 
  options[:ejb2]=false
  options[:security]=false
  options[:javadoc]=true
  options[:installRessources]=true
  options[:target_ejbconf] = nil
  options[:autoNewFileCreation]=true
  options[:webContentRelativeDir]="./WebContent/"
  options[:javaClassRelDir]=nil
  options[:generateAntBuildFile]=false
  options[:silentlyForceUnknownDatatypeToString]=false
  options[:allowAutomaticCodeDeletion]=false
  options[:generateCompositionDiagram] = false
  options[:checkForAbstractAndInheritance]=false
  options[:generateXMLStrutsForm]=false
  options[:java_addJavaEnumInterface]=false
  options[:silentlyTruncateTableName]=false
  options[:benchmark]=false
  options[:profile]=false
  options[:logFileWrite]=false
  options[:javaFilePathRegexp]=[]
  options[:bpm_javaSubPackage]="bpm"
  options[:struts_useSpring]=true
  options[:db_useExtraTypeParameterForFindAll]=true
  options[:bpm_addPingNode]=false
  options[:jpaConfigDir] = nil

  options[:rel_mapping] = "none"
  options[:groovyExperimental]=false
  options[:daemon] = false 

  options[:dbTypeDiscriminator]=DB_TYPE_DISCRIMINATOR[0]
  options[:dbDiscriminatorCacheRelFile]="dbDiscriminatorCache.rb"
  options[:ddl_mode]="create"
  options[:simulateNotImplementedMethods]=false
  options[:db_useStereotypeMarker]=false
  options[:versionSignature]=nil
  #options[:db_stereotypeMarkerName]=false
  options[:enableTestData] = false
  options[:testDataRDF] = nil
  options[:testDataRDFS] = nil
  
  
  options[:updateKB]=false
  options[:kbTargetfile]="defaultKbTargetFile"

  options[:excludeNonTestFiles]=false
  options[:includeTestFiles]=true

  options[:java_failIfNonUniqueName]=true

  options[:rsm6WebDocURI]=""
  options[:jpdl]=[]
  options[:ntbpm]=[]
  options[:bpm]=false
  options[:skipNoReverseMarker]=false

  options[:derby]=false

  #  options[:hib_dialect]="org.hibernate.dialect.MySQL5InnoDBDialect"
  #
  #
  #   options[:hib_dialect]="org.hibernate.dialect.MySQL5InnoDBDialect"
  #   options[:hib_connection_driver_class]="com.mysql.jdbc.Driver"
  #   options[:hib_connection_url]=nil
  #   options[:hib_connection_username]="testuser"
  #   options[:hib_connection_password]="testpwd"
  #
  #   options[:hib_dialect]="org.hibernate.dialect.DerbyDialect"
  #   options[:hib_connection_driver_class]="org.apache.derby.jdbc.EmbeddedDriver"
  #   options[:hib_connection_url]="jdbc:derby:realty;create=true"
  #   options[:hib_connection_username]="testuser"
  #   options[:hib_connection_password]="testpwd"


  #cf: http://www.ruby-doc.org/core/classes/OptionParser.html
  OptionParser.new do |opts|
    opts.banner =<<ENDHELP
#{File.basename(startupFile)} is a command line utility to generate Java Code from a UML2 model stored in a UML2/RDF model file.

    This command line is a front end to OntoMDE generator offering a set of pre-packaged, yet powerfull generation rules.

    This Java code generator is full featured and covers many UML features (incremental generation, loading of additional MDA transformation rules, ...)

#{h3}Example: generate java code from one model file
  $ #{File.basename(startupFile)} --nt myUmlModel.emx.nt

#{h3}Example: generate java code in a custom directory
  $ #{File.basename(startupFile)} --nt myUmlModel.emx.nt --target ./src

#{h3}Usage:
  #{File.basename(startupFile)} [options]
ENDHELP

    opts.separator "#{h3}Source and Target options :"
    opts.separator ""

    opts.on("--nt FILE1.nt,FILE2.nt, ...",Array,": Source UML2 model(s) (exported from a UML case tool)","default: --nt #{options[:nt]}") do |v|
      options[:nt].concat(v)
    end
    opts.separator ""

    opts.on("--ntList FILE1,FILE2,...",Array,": File containing a list of nt file to be loaded") do |v|
      v.each { |fn|  File.open(fn) { |f| f.each_line { |line|
            next if line.empty? || line[0]=='#'[0]
            options[:nt]<<( "#{File.dirname(fn)}/#{line.chomp}" )
          }}}
    end

    opts.on("-l","--load FILE1.rb,File2.rb",Array,": Optionnal ruby extension or setup file (used as well new datatype declaration mappings, as for any generation customisation)","default: --load #{options[:load]}" ) do |v|
      options[:load].concat(v)
    end

    opts.on("-l","--loadDir DIRECTORY1,..",Array,": Optionnal ruby extension or setup file","(used as well new datatype declaration mappings, as for any generation customisation)","default: --loadDir " ) do |v|
      v.each { |d|
        Dir.foreach(d) { |f|
          next unless f =~ /\.rb$/
          puts "f=#{f}"
          options[:load]<<("#{d}/#{f}")
        }
      }
    end

    opts.on("--loadList FILE_list1,FILE_list2, ...",Array,": File containing a list of ruby file to be loaded","(same as --load on each item)") do |v|
      v.each { |fn|  File.open(fn) { |f| f.each_line { |line|
            next if line.empty? || line[0]=='#'[0]
            options[:load]<<( "#{File.dirname(fn)}/#{line.chomp}" )
          }}}
    end

    opts.on("--javaRelativeDir DIRECTORY",": Relative destination directory for generated java files, properties, ...","relative to --targetDir","default: --javaRelativeDir #{options[:javaRelativeDir]}") do |v|
      options[:javaRelativeDir] = v
    end

    opts.on("--webResourcesDir DIRECTORY",": Relative destination directory for generated Web Resources properties, ...","relative to --targetDir","default: --webResourcesDir #{options[:webResourcesDir]}") do |v|
      options[:webResourcesDir] = v
    end

    opts.on("--javaFilePathRegexp REGEXP@DIRECTORY",": Relative destination directory for generated java files, properties, ...","relative to --targetDir","default: --javaFilePathRegexp #{options[:javaFilePathRegexp]}") do |v|
      re=Regexp.new(v.split('@')[0])
      p=v.split('@')[1]
      options[:javaFilePathRegexp]<<([re,p])
    end

    opts.on("--targetDir DIRECTORY",": Target generation root directory","default: --targetDir #{options[:targetDir]}") do |v|
      options[:targetDir] = v
    end

    opts.separator "#{h3}Model pre-processors options :"
    opts.separator ""

    opts.on("--[no-]withMultipleInheritance",": Apply pattern to map UML model with multiple inheritance to Java compliant model.","  (Class inheritance is mapped to interface implementation)",%{default: --#{options[:withMultipleInheritance]?"":"no-"}withMultipleInheritance}) do |v|
      options[:withMultipleInheritance] = v
    end

    opts.on("-p","--[no-]withAutoImplementProperty",": Generate automatically missing property in concrete class implementing an interface uml properties","  (feature introduced for model redondancy reduction)","default: --#{options[:withAutoImplementProperty]?'':'no-'}withAutoImplementProperty") do |v|
      options[:withAutoImplementProperty] = v
    end

    opts.on("-o","--[no-]withAutoImplementOperation",": Generate automatically missing operations in concrete class implementing an interface","  (feature introduced for  model redondancy reduction)","default: --#{options[:withAutoImplementOperation]?'':'no-'}withAutoImplementOperation") do |v|
      options[:withAutoImplementOperation] = v
    end

    opts.on("--[no-]makeCompositionBiNavigable",": Force compositions to be bi-navigable","(Feature introduced for web persistence handling)",%{default: --#{options[:makeCompositionBiNavigable]?"":"no-"}makeCompositionBiNavigable}) do |v|
      options[:makeCompositionBiNavigable] = v
    end


    opts.separator "#{h3}Model enhancement options:"
    opts.separator ""

    opts.on("-a","--[no-]withEnumAssignable",": Generates for each class and interfaces an enum containing assignable class","(required for creators)","NOTE: also disable generation of createAndAdd methods",%{default: --#{options[:withEnumAssignable]?"":"no-"}withEnumAssignable}) do |v|
      options[:withEnumAssignable] = v
    end

    opts.on("--enumAssignableSubPackage SUBDIR",": Directory where enumAssignable artefacts wil be generated",%{default: --enumAssignableSubPackage #{options[:enumAssignableSubPackage]} }) do |v|
      options[:enumAssignableSubPackage] = v
    end


    opts.on("-f","--[no-]withGenerateMethodForm",": Apply a pattern to generate a form (as a class) for every method of the model.","(Feature introduced for web form handling)",%{default: --#{options[:withGenerateMethodForm]?"":"no-"}withGenerateMethodForm}) do |v|
      options[:withGenerateMethodForm] = v
    end


    opts.separator "#{h3}Pre-Java 5 compatibility options:"
    opts.on("-e","--[no-]withEnumAsString",": Generate additional string getter and setter","for properties with an enum type, so enums property can be manipulated as if it was a string","  (feature introduced","  for Flex interoperability)","default: --#{options[:withEnumAsString]?'':'no-'}withEnumAsString") do |v|
      options[:withEnumAsString] = v
    end

    opts.separator ""
    opts.separator "#{h3} Tests Data options:"
    opts.separator ""
    
    opts.on("--updateKB",": Create or update protege 2000 knowledge base project (for creating tests data and junit tests bases on use cases.)","default: --#{options[:updateKB]?'':'no-'}updateKB") do |v|
      options[:updateKB] = v
    end
    
    opts.on("--kbTargetfile FILENAME  _WITHOUT_EXTENSION",": Protege data test file to be generated or update.","This generates a protege/2000 project file to be used for editing tests data attached to test instances.","default: --kbTargetfile #{options[:kbTargetfile]}") do |v|
      options[:kbTargetfile] = v
    end
    

    opts.on("--[no-]excludeNonTestFiles",": Do not generate files which are not test files","junit,data,...","default: --#{options[:excludeNonTestFiles]?'':'no-'}excludeNonTestFiles") do |v|
      options[:excludeNonTestFiles] = v
    end

    opts.on("--[no-]includeTestFiles",": Include test files in generation","junit,data,...","default: --#{options[:includeTestFiles]?'':'no-'}includeTestFiles") do |v|
      options[:includeTestFiles] = v
    end

    #    opts.on("--[no-]enableTestData","enable data tests options",%{default: --#{options[:enableTestData]?"":"no-"}enableTestData}) do |v|
    #      options[:enableData] = v
    #    end

    opts.on("--testDataRDF RDFFILE",": Data file in RDF format") do |v|
      options[:enableTestData] = true
      options[:testDataRDF] = v
    end
    opts.on("--jpaConfigDir JPA_CONFIG_DIR",": Directory for the persistence.xml") do |v|
      options[:jpaConfigDir] = v
    end
    opts.on("--testDataRDFS RDFSFILE",": Data file format in RDFS format","If absent, this RDFSFILE will be guessed from --dataRDF") do |v|
      options[:enableTestData] = true
      options[:testDataRDFS] = v
    end

    opts.separator "#{h3}Access control enhancement options:"
    opts.separator ""

    opts.on("--[no-]security",": Activate authentification and access control",%{default: --#{options[:security]?"":"no-"}security}) do |v|
      options[:security] = v
    end


    opts.separator "#{h3}BPM enhancement options:"
    opts.separator ""

    opts.on("--[no-]bpm",": Activate bpm processing",%{default: --#{options[:bpm]?"":"no-"}bpm}) do |v|
      options[:bpm] = v

      # if bpm is set, J2EE is mandatory (spring use is deactivated)
      options[:struts_useSpring]=!v
    end
    
    opts.on("--[no-]crank","Enable crank generation.","default: --#{options[:crank]?'':'no-'}crank") do |v|
      options[:crank] = v
      options[:java_addJavaEnumInterface]=true
    end

    #    opts.on("--ntBPM FILE1.nt,FILE2.nt, ...",Array,"Source BPM model(s) (exported from a BPM modeling tool in nt format)","default: --ntBPM #{options[:ntBPM]}") do |v|
    #      options[:ntBPM].concat(v)
    #    end

    opts.on("--jpdl FILE1.nt,FILE2.nt, ...",Array,": Source jpdl xml BPM model(s)","default: --jpdl #{options[:jpdl]}") do |v|
      options[:bpm]=true
      options[:jpdl].concat(v)
    end

    opts.on("--jpdlList FILE_list1,FILE_list2, ...",Array,": File containing a list of jpdl file to be loaded") do |v|
      options[:bpm]=true
      v.each { |fn|  File.open(fn) { |f| f.each_line { |line|
            next if line.empty? || line[0]=='#'[0]
            options[:jpdl]<<( "#{File.dirname(fn)}/#{line.chomp}" )
          }}}
    end

    opts.on("--bpm_javaSubPackage [SUBPACKAGE]",": Relative sub package where will be generated service class","(enums for transitions,...)",%{default: --bpm_javaSubPackage #{options[:bpm_javaSubPackage]}}) do |v|
      options[:bpm_javaSubPackage] = v
    end

    opts.separator ""
    opts.separator "#{h3}Flex integration options:"
    opts.separator ""

    opts.on("--[no-]generateXMLStrutsForm",": Add XML form serializer.","feature introduced for FLEX",%{default: --#{options[:generateXMLStrutsForm]?"":"no-"}generateXMLStrutsForm}) do |v|
      options[:generateXMLStrutsForm] = v
    end

    opts.on("--[no-]flex",": Generate flex code",%{default: --#{options[:flex]?"":"no-"}flex}) do |v|
      options[:flex] = v
      # force generateXMLStrutsForm if flex is activated
      options[:generateXMLStrutsForm] = v if v
    end

    opts.separator ""
    opts.separator "#{h3}Database persistence options:"
    opts.separator ""

    code_list = (OR_MAPPING_ALIASES.keys + OR_MAPPING).join(',')
    opts.on("-m","--relational_mapping objr", OR_MAPPING, OR_MAPPING_ALIASES, ": Select object/relation library", "  (#{code_list})","default: --relation_mapping #{options[:rel_mapping]}") do |encoding|
      options[:rel_mapping] = encoding
    end

    opts.on("--[no-]db_useStereotypeMarker",": Are persistent capable classes marked with a stereotype",%{default: --#{options[:db_useStereotypeMarker]?"":"no-"}db_useStereotypeMarker}) do |v|
      options[:db_useStereotypeMarker] = v
    end

    opts.on("--[no-]silentlyTruncateTableName",": Silently truncate generated table name to maximum sgbd allowed length.",%{default: --#{options[:silentlyTruncateTableName]?"":"no-"}silentlyTruncateTableName}) do |v|
      options[:silentlyTruncateTableName] = v
    end

    opts.on("-d","--ddl_mode [MODE]",": SGBD schema creation mode","(create/update/...)",%{default: --ddl_mode #{options[:ddl_mode]}}) do |v|
      options[:ddl_mode] = v
    end

    opts.on("-s","--[no-]simulateNotImplementedMethods",": Replace unimplemeted method with a simulation method.",%{default: --#{options[:simulateNotImplementedMethods]?"":"no-"}simulateNotImplementedMethods}) do |v|
      options[:simulateNotImplementedMethods] = v
    end

    opts.on("-s","--[no-]java_addSuggester",": Add or remove the suggester method.",%{default: --#{options[:java_addSuggester]?"":"no-"}java_addSuggester}) do |v|
      options[:java_addSuggester] = v
    end


    code_list2 = (DB_TYPE_DISCRIMINATOR_ALIASES.keys + DB_TYPE_DISCRIMINATOR).join(',')
    opts.on("--dbTypeDiscriminator [objr]", DB_TYPE_DISCRIMINATOR, DB_TYPE_DISCRIMINATOR_ALIASES, ": Column type used to store an object type in database.", "  (#{code_list2})","default: --dbTypeDiscriminator #{options[:dbTypeDiscriminator]}") do |encoding|
      options[:dbTypeDiscriminator] = encoding
    end

    opts.on("--dbDiscriminatorCacheRelFile [RBFILE]",": File where db discriminator will be saved","to allow subsquent generation to use the same ids","NOTE: generated file will not be used, unless specified using --load option",%{default: --dbDiscriminatorCacheRelFile #{options[:dbDiscriminatorCacheRelFile]}}) do |v|
      options[:dbDiscriminatorCacheRelFile] = v
    end

    opts.on("--[no-]mysql",": Optimize for mysql.",%{default: --#{options[:mysql]?"":"no-"}mysql}) do |v|
      options[:mysql] = v
    end
    opts.on("--[no-]derby",": Optimize for derby.",%{default: --#{options[:derby]?"":"no-"}derby}) do |v|
      options[:derby] = v
    end

    opts.separator ""
    opts.separator "#{h3}Webapp options:"

    opts.on("--[no-]struts",": Enable struts generation.","default: --#{options[:struts]?'':'no-'}struts") do |v|
      options[:struts] = v
      options[:java_addJavaEnumInterface]=true
    end

    opts.on("--[no-]java_addJavaEnumInterface",": Add Enum Interface.","default: --#{options[:java_addJavaEnumInterface]?'':'no-'}java_addJavaEnumInterface") do |v|
      options[:java_addJavaEnumInterface] = v
    end
    opts.on("-u","--[no-]useUnzip",": Use unzip to install resources.","default: --#{options[:useUnzip]?'':'no-'}useUnzip") do |v|
      options[:useUnzip] = v
    end

    opts.on("-c","--[no-]message-check",": Check message ressources consistency.","default: --#{options[:messageCheck]?'':'no-'}message-check") do |v|
      options[:messageCheck] = v
    end

    opts.on("--webContentRelativeDir [DIRECTORY]",": Directory where webapp artefacts wil be generated (WEB-INF, META-INF, JSP, ...)",%{default: --webContentRelativeDir #{options[:webContentRelativeDir]}}) do |v|
      options[:webContentRelativeDir] = v
    end

    opts.on("--strutsActionFormPackage [SUBPACKAGE]",": SubPackage where to generate struts related classes",%{default: --strutsActionFormPackage #{options[:strutsActionFormPackage]}}) do |v|
      options[:strutsActionFormPackage] = v
    end




    opts.separator ""
    opts.separator "#{h3}EJB options:"
    opts.on("--[no-]ejb2",": Enable ejb2 experimental processing","default: --#{options[:ejb2]?'':'no-'}ejb2") do |v|
      options[:ejb2] = v
    end

    opts.on("-t","--target_ejbconf DIRECTORY",": Destination directory for generated files","default: --target_ejbconf #{options[:target_ejbconf]}") do |v|
      options[:target_ejbconf] = v
    end

    opts.separator ""
    opts.separator "#{h3}Misc. options:"
    opts.on("--[no-]generateAntBuildFile",": Generates a default ant build file",%{default: --#{options[:generateAntBuildFile]?"":"no-"}generateAntBuildFile}) do |v|
      options[:generateAntBuildFile] = v
    end
    opts.on("--versionSignature version",": Adds a version signature to generated code, so old cold will not compile.","(an implemented interface is added to class and interfaces)","default: --versionSignature #{options[:versionSignature]}") do |v|
      options[:versionSignature] = v
    end

    opts.on("--[no-]skipNoReverseMarker",": Only write markers when reverse is already set to yes. Usefull to get rid of unused reverse zone and get a better code browsing experience.","default: --#{options[:skipNoReverseMarker]?'':'no-'}skipNoReverseMarker") do |v|
      options[:skipNoReverseMarker] = v
    end

    opts.on("--[no-]silentlyForceUnknownDatatypeToString",": Silently map an unknown datatype to String. This feature should only be used for testing.",%{default: --#{options[:silentlyForceUnknownDatatypeToString]?"":"no-"}silentlyForceUnknownDatatypeToString}) do |v|
      options[:silentlyForceUnknownDatatypeToString] = v
    end

    opts.on("--[no-]java_failIfNonUniqueName",": Stop generation immediately when a name unicitiy constraint failure is detected.",%{default: --#{options[:java_failIfNonUniqueName]?"":"no-"}java_failIfNonUniqueName}) do |v|
      options[:java_failIfNonUniqueName] = v
    end
    opts.on("--[no-]groovyExperimental",": Add experimental groovy features (alpha).",%{default: --#{options[:groovyExperimental]?"":"no-"}groovyExperimental}) do |v|
      options[:groovyExperimental] = v 
    end

    opts.on("--[no-]daemon",": Run this script as daemon.",%{default: --#{options[:daemon]?"":"no-"}daemon}) do |v|
      options[:daemon] = v 
    end
    
    opts.separator "#{h3}Report generator:"

    opts.on("--rsm6WebDocURI URL",": Base URL of RSM6 model html export","default: -- #{options[:rsm6WebDocURI]}") do |v|
      options[:rsm6WebDocURI] = v
    end


    opts.on("--[no-]generateCompositionDiagram",": Generate a composition diagram (in graphviz dot file format)",%{default: --#{options[:generateCompositionDiagram]?"":"no-"}generateCompositionDiagram}) do |v|
      options[:generateCompositionDiagram] = v
    end

    opts.on("--[no-]checkForAbstractAndInheritance",": Check model for abstract class with inheriting classes. Stop generation if an invalid class is encountered.",%{default: --#{options[:checkForAbstractAndInheritance]?"":"no-"}checkForAbstractAndInheritance}) do |v|
      options[:checkForAbstractAndInheritance] = v
    end

    opts.separator "#{h3}Debug options:"

    opts.on("--[no-]salvage",": Tries to handle highly defective model using best guess.","This feature is only intended for **quick demo** purposes.","Do not use for serious work!",%{default: --#{options[:salvage]?"":"no-"}salvage}) do |v|
      options[:salvage] = v
    end

    opts.separator "#{h3}File creation options:"

    opts.on("--[no-]autoNewFileCreation",": Allows generator to create new file on its own","This feature should be deactivated for project under version control so no new file can be added to a project without a developper approval.","This feature should also be deactivated to help keep track of file rename and allow project refactoring",%{default: --#{options[:autoNewFileCreation]?"":"no-"}autoNewFileCreation}) do |v|
      options[:autoNewFileCreation] = v
    end

    opts.on("--[no-]allowAutomaticCodeDeletion",": Automatically ignore deleted protected code.","If disabled, generator will halt when reversed code is not reused in file newly created",%{default: --#{options[:allowAutomaticCodeDeletion]?"":"no-"}allowAutomaticCodeDeletion}) do |v|
      options[:allowAutomaticCodeDeletion] = v
    end

    opts.on("-s","--[no-]dry-run",": Do a dry run without executing actions..","No file will be changed neither created on disk",%{default: --#{options[:dryRun]?"":"no-"}dry-run}) do |v|
      options[:dryRun] = v
    end

    opts.on("-v", "--[no-]verbose", ":Run in verbose mode",%{default: --#{options[:verbose]?"":"no-"}verbose}) do |v|
      options[:verbose] = v
    end

    opts.on("-v", "--[no-]benchmark", ": Run in benchmark mode","Feature usefull for optimizing generation time",%{default: --#{options[:benchmark]?"":"no-"}benchmark}) do |v|
      options[:benchmark] = v
    end

    opts.on("-v", "--[no-]profile", ": Run in profile mode","Feature usefull for optimizing generation time",%{default: --#{options[:profile]?"":"no-"}profile}) do |v|
      options[:profile] = v
      require 'unprof' if options[:profile]
    end

    opts.on("-v", "--[no-]logFileWrite", ": Log file write access to screen",%{default: --#{options[:logFileWrite]?"":"no-"}logFileWrite}) do |v|
      options[:logFileWrite] = v
    end

    opts.on("--[no-]selfTestAndExit", ": Self test and exit.","(loads every dependencies)","(Note: used by binary generator)",%{default: --#{options[:selfTestAndExit]?"":"no-"}selfTestAndExit}) do |v|
      options[:selfTestAndExit] = v
    end

    opts.on("--[no-]backTrace", ": Display back trace on error.",%{default: --#{options[:backTrace]?"":"no-"}backTrace}) do |v|
      options[:backTrace] = v
    end



    # No argument, shows at tail.  This will print an options summary.
    # Try it and see!
    opts.on_tail("-h", "--help", ": Show this message") do
      puts opts
      exit 1
    end

    opts.on_tail("--help-rdoc", ": Show help in rdoc format") do
      #x=opts.to_s.
      #Set very wide columns to disable column wrapping
      opts.summary_indent="~"*300
      opts.summary_width=999
      puts opts.to_s.
        gsub(/^##/,'==').
        gsub(/(default:)/,"\n\n<i>\\1</i>").
        gsub(/^[^a-zA-Z\n]*(-[^:\n]*:)/,"===\\1\n\n").
        gsub(/  */," ").
        gsub(/  */," ").
        gsub(/~~*/,"").
        to_s


      #gsub(/^[ \t]*-([a-zA-Z])[ \t]*\n/,'-\1 ,').
      #gsub(/^[ \t]*/,'').

      #gsub(/(^[^:\n]*--*[^\t\n ]*)/,"<b>\\1</b>").
	

      exit 1
    end

  end.parse!

  if (ARGV.length > 0) && options[:nt].nil?
    log.warn("**********************")
    log.warn("DEPRECATED SYNTAX USED")
    log.warn("For help:")
    log.warn("#{File.basename(startupFile)} --help")
    log.warn("**********************")
    options[:nt]=[]
    ARGV.each { |f| options[:nt]<< f }
    ARGV.clear
  end

  if ARGV.length > 0
    raise Exception.new("An error occured while processing command line arguments. Unparseable paramater : '#{ARGV}'")
  end

  begin # of the rescue section



    if options[:selfTestAndExit ]
      # load every depencies
      # used by rubyscript2exe to automatically populate
      # en inventory of used dependencies
      Kernel::DEPS.each { |deps|
        require deps
      }
      exit 0
    end

    if options[:bpm]
      require_deps 'ontomde-uml2-jpdl'
    end

    if options[:daemon]
      puts "dameon"
      require_deps 'ontomde-inspector'
    end
    
    if options[:struts] #||options[:useUnzip] || options[:messageCheck]
      options[:withGenerateMethodForm]=true
      require_deps 'ontomde-uml2-struts'
    else
      options[:installRessources]=false
      options[:messageCheck]=false
      options[:useUnzip]=false
    end

    if options[:crank] #||options[:useUnzip] || options[:messageCheck] 
      require_deps 'ontomde-uml2-crank'
    end

    if options[:testDataRDFS].nil? && options[:testDataRDF]=~/\.rdf$/
      #guess rdfs file name
      options[:testDataRDFS]=options[:testDataRDF].gsub(/\.rdf$/,'.rdfs')
    end

    if options[:ejb2]
      require_deps 'ontomde-uml2-ejb2'
    end

    if options[:rel_mapping]=='jpox'
      require_deps 'ontomde-uml2-jdo'
    elsif options[:rel_mapping]=='hibernate'
      require_deps 'ontomde-uml2-jpa'
    elsif options[:rel_mapping]=='none'
      # nop
    else
      m="unknown object/relational mapping library (#{options[:rel_mapping]})"
      log.error(m)
      raise Exception.new(m)
    end

    if options[:flex]
      require_deps 'ontomde-uml2-flex'
    end

    if options[:enableTestData]
      puts "ENABLED testDATA" if options[:verbose]
      require_deps 'ontomde-uml2-kb'
      require_deps 'ontomde-uml2-kbjava'
    end
    options[:db]=(options[:rel_mapping] != "none")
    options[:javaDir]=options[:targetDir]+"/"+options[:javaRelativeDir]
    options[:flexDir]=options[:targetDir]+"/"+options[:flexRelativeDir]

    if !options[:jpaConfigDir].nil?
      options[:jpaConfigDir]=options[:targetDir]+"/"+options[:jpaConfigDir]
    end
    options[:webResourcesDir]=options[:targetDir]+"/"+options[:webResourcesDir]
    options[:webContentDir]=options[:targetDir]+"/"+options[:webContentRelativeDir]
    options[:load].each { |f|
      puts "INFO : Loading custom transformation from #{f} in #{FileUtils.pwd}" if options[:verbose]
      begin
        # if require is used add "./" to avoid
        # file not found from binary generated with rubyscript2exe
        require "./#{f}"
      rescue Exception => e
        log.error %{
*************** ERROR ***************
** Error processing
** --load #{f}
** (pwd=#{FileUtils.pwd})
** Exception:
** #{e}
*************** ERROR ***************

        }
        raise e

      end
    }




    model=Crdf_Model.new
    model.mtk_context(options) {
      if model.context[:benchmark]
        require 'benchmark'
        include Benchmark
        Benchmark.benchmark("        " + CAPTION, 12, FMTSTR, "load", "bpm","tests","mda1","mda2","mda3","mda4",".java",".jsp","misc","flex",">total",">avg") do |x|
          t1=x.report("load") { step_load(model) }
          t1a=x.report("kb") { step_generateKb(model) }
          t2=x.report("bpm") { step_bpm(model) }
          t5=x.report("tests") { step_generate_tests(model) }
          t3a=x.report("mda1") { step_transform10(model) }
          t3b=x.report("mda2") { step_transform20(model) }
          t3c=x.report("mda3") { step_transform30(model) }
          t3d=x.report("mda4") { step_transform40(model) }
          t4=x.report(".java") { step_generate_java(model) }
          t6=x.report("jsp") { step_generate_struts(model) }
          t7=x.report("misc") { step_generate_misc(model) }
          t8=x.report("flex") { step_generate_flex(model) }


          puts "***************************************************"
          puts "             user     system      total        real"
          [t1 ,t1a,t2 ,t3a,t3b,t3c,t3d,t4 ,t5 ,t6 ,t7,t8,t1+t1a+t2+t3a+t3b+t3c+t3d+t4+t5+t6+t7+t8,(t1+t1a+t2+t3a+t3b+t3c+t3d+t4+t5+t6+t7+t8)/12]
        end
      else
        step_load(model)
        step_generateKb(model)
        step_bpm(model)
        step_generate_tests(model)
        step_transform10(model)
        step_transform20(model)
        step_transform30(model)
        step_transform40(model)
        step_generate_java(model)
        step_generate_struts(model)
        step_generate_crank(model)
        step_generate_misc(model)
        step_generate_flex(model)
      end
      
      model.inspector_start_daemon(startupFile) if options[:daemon]
      
    }
  rescue Exception => e
    if options[:backTrace]
      raise e
    else
      puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      puts e
      puts "use --backTrace to display full backtrace"
      puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      exit(1)
    end
  rescue => e
    if options[:backTrace]
      raise e
    else
      puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      puts e
      puts "use --backTrace to display full backtrace"
      puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      exit(1)
    end
  rescue RuntimeError => e
    if options[:backTrace]
      raise e
    else
      puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      puts e
      puts "use --backTrace to display full backtrace"
      puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      exit(1)
    end
  end

end

#say(x) ⇒ `Object`

# File 'lib/ontomde-java-frontend/command.rb', line 783

def say(x)
  #puts("# #{File.basename(startupFile)}: #{x}")
  puts "  :#{x}"
end

#step_bpm(model) ⇒ `Object`

Process bpm enhancement.

# File 'lib/ontomde-java-frontend/command.rb', line 824

def step_bpm(model)
  return unless model.context[:bpm]
  say "processing bpm"
  model.bpm_addPingNode!
  model.bpm_handleProcessMethods!
  model.bpm_transform!
  #model.bpm_graphGen_dot
end

#step_generate_crank(model) ⇒ `Object`

# File 'lib/ontomde-java-frontend/command.rb', line 957

def step_generate_crank(model)
  return if model.context[:excludeNonTestFiles]
  if(model.context[:crank])
    model.crank_generate_facesconfig
    model.crank_generate_facelets
    model.crank_generate_home
    
  end
end

#step_generate_flex(model) ⇒ `Object`

generate flex artefacts

# File 'lib/ontomde-java-frontend/command.rb', line 945

def step_generate_flex(model)
  return unless model.context[:flex]
  say "processing flex"
  model.mtk_context(:javaDir => "#{model.context[:flexDir]}/src/", :javaFilePathRegexp => nil) {
	  model.flex_generateVO
	  model.flex_generateMXML
  }
  model.mtk_context(:javaDir => "#{model.context[:flexDir]}/script/", :javaFilePathRegexp => nil) {
	  model.flex_generateImportationAS
  }
end

#step_generate_java(model) ⇒ `Object`

write java files to disk

# File 'lib/ontomde-java-frontend/command.rb', line 910

def step_generate_java(model)
  say "processing java"
  model.java_generate
end

#step_generate_misc(model) ⇒ `Object`

generate misc. artefacts

# File 'lib/ontomde-java-frontend/command.rb', line 934

def step_generate_misc(model)
  return if model.context[:excludeNonTestFiles]
  say "processing misc."
  model.db_saveDB_DISCRIMINATOR if model.context[:db]
  model.db_generateConfiguration if model.context[:db]
  model.java_generateAntBuildFile
  model.java_generatePackageDoc

end

#step_generate_struts(model) ⇒ `Object`

write struts files to disk

# File 'lib/ontomde-java-frontend/command.rb', line 916

def step_generate_struts(model)
  return if model.context[:excludeNonTestFiles]
  if(model.context[:struts])
    say "processing struts"
    model.struts_generate_webxml
    model.struts_struts_config_generate
    model.struts_validator_generate
    model.struts_validation_generate
    model.struts_copyReloadDefinitionsActionClass

    model.struts_index_generate
    model.struts_edit_generate
    model.struts_messageResources_generate
    model.struts_generateSpringApplicationContext
  end
end

#step_generate_tests(model) ⇒ `Object`

process tests loaded from protege/2000 and generate test artefacts.

# File 'lib/ontomde-java-frontend/command.rb', line 893

def step_generate_tests(model)
  if(model.context[:enableTestData])
    say "processing tests"
    ignoreHeader=true
    data_model=Crdf_ProtegeDataModel.new
    data_model.loadMetaModelFromFile(model.context[:testDataRDFS],ignoreHeader)
    data_model.loadModelFromFile(model.context[:testDataRDF],ignoreHeader)
    data_model.kbjava_umlSourceModel = model

    data_model.kbjava_generateJavaJunit!
    data_model.mtk_context(:build=>%{#{model.context[:testRelativeDir]}}) {
      data_model.kbjava_generate
    }
  end
end

#step_generateKb(model) ⇒ `Object`

Generate protege 2000 knowlege base

# File 'lib/ontomde-java-frontend/command.rb', line 817

def step_generateKb(model)
  return unless model.context[:updateKB]
  say "generating KB project"
  model.generateRDFS(model.context[:kbTargetfile])
end

#step_load(model) ⇒ `Object`

load meta-model(s) and model(s)

# File 'lib/ontomde-java-frontend/command.rb', line 791

def step_load(model)

  if model.context[:bpm]
    say "loading bpm meta-model"
    model.bpm_loadBPM
  end
  say "loading UML2 meta-model"
  model.loadUml2
  i=0
  model.context[:nt].each { |f|
    i=i+1
    say "loading uml data from '#{f}'" if model.context[:verbose]
    model.loadModelFromFile(f)
  }

  model.umlx_processShortcuts!

  model.context[:jpdl].each { |f|
    i=i+1
    say "loading bpm data from'#{f}'" if model.context[:verbose]
    model.bpm_loadJPDL(f)
  }
  say "# Loaded #{i} models." if model.context[:verbose]
end

#step_transform10(model) ⇒ `Object`

Enhance UML model

# File 'lib/ontomde-java-frontend/command.rb', line 834

def step_transform10(model)
  say "processing UML model structure"
  model.umlx_tryToSalvageErrors!
  model.struts_createDataTypeHelpers! if model.context[:struts]

  model.java_addJavaEnumInterface!
  model.umlx_makeCompositionNavigable!
  model.umlx_mapMultipleInheritanceToInterface! if model.context[:withMultipleInheritance]

  model.umlx_checkAbstractAndInheritance

  model.umlx_generateCompositonDotDiagram
  if model.context[:ejb2]
    model.ejb2_transform!
  end
  #Should be placed before autoImplementoperation: otherwise autoImplementedMethod are not considered as business method
  model.umlx_MarkAllAsbusinessMethod!

  
  model.java_addEnumAssignable! if model.context[:withEnumAssignable]
  model.umlx_autoImplementProperty! if model.context[:withAutoImplementProperty]
  model.umlx_autoImplementOperation! if model.context[:withAutoImplementOperation]

  model.java_addGroovyImplementations! if model.context[:groovyExperimental]
  
  model.struts_addAllOperationAggregateParameterClass!
  model.java_addEnumCompatibilityLayerProperties! if model.context[:withEnumAsString]
  model.db_addDAO! if model.context[:db]
  model.java_transform!
end

#step_transform20(model) ⇒ `Object`

# File 'lib/ontomde-java-frontend/command.rb', line 864

def step_transform20(model)
  
  

  model.db_addPersistence! if model.context[:db]

  model.struts_addActionLocaleForm! if model.context[:struts]
  model.struts_addPerClassElement! if model.context[:struts]

  model.db_addTestImplementations! if model.context[:simulateNotImplementedMethods]
  model.struts_installRessources if model.context[:installRessources ]
  model.struts_getFunctionalException if model.context[:struts]
end

#step_transform30(model) ⇒ `Object`

# File 'lib/ontomde-java-frontend/command.rb', line 877

def step_transform30(model)
  model.struts_getExceptionHandlerClass if model.context[:struts]
  model.uml_addVersionSignature

  if model.context[:crank]
    model.crank_generate_context
    model.crank_generate_validation
  end
  model.umlx_populateSecuredMethodEnumeration if model.context[:security]
end

#step_transform40(model) ⇒ `Object`

# File 'lib/ontomde-java-frontend/command.rb', line 887

def step_transform40(model)
  model.umlx_populateSecuredPropertyEnumeration if model.context[:security]
  model.umlx_processSecuredElements if model.context[:security]
end

Top Level Namespace

Defined Under Namespace

Constant Summary collapse

Instance Method Summary collapse

Instance Method Details

#removeVersionInARGV ⇒ Object

#runJavaFrontEnd(startupFile) ⇒ Object

#say(x) ⇒ Object

#step_bpm(model) ⇒ Object

#step_generate_crank(model) ⇒ Object

#step_generate_flex(model) ⇒ Object

#step_generate_java(model) ⇒ Object

#step_generate_misc(model) ⇒ Object

#step_generate_struts(model) ⇒ Object

#step_generate_tests(model) ⇒ Object

#step_generateKb(model) ⇒ Object

#step_load(model) ⇒ Object

#step_transform10(model) ⇒ Object

#step_transform20(model) ⇒ Object

#step_transform30(model) ⇒ Object

#step_transform40(model) ⇒ Object