module org/webdsl/dsl/utils/compiler-options

imports
  libstratego-lib
  libstratego-xtc
  libstratego-tool-doc
  org/webdsl/dsl/syntax/-

strategies

  set-appname-and-dirs = with(
        path := <?FILE(<id>)> //<path-of-xtc-file>
      ; (appname, _) := <split-before> (<base-filename> path, ".app")
      ; dirname := <dirname> path
      ; rules ( AppName := appname )
      ; rules ( DirName := dirname )
    )

strategies //set working directory

  webdsl-verbose-option =
    ArgOption("--dir"
    , ?dir; rules( WorkingDir := dir ); <chdir> dir
    , !HelpString("--dir x", "Set working directory to x.")
    )

  extend-set-default-config = rules( WorkingDir := <getcwd> ); fail

strategies // command-line options

  set-default-config =
    rules(
      OptionTypecheck := True()
      Stage           := 0
      VerbosityLevel  := 1
    )
  ; not(extend-set-default-config; debug(!"Internal Error: extend-set-default-config rule should fail"); <exit> 1)

  webdslc-options =
       webdsl-version-option  	
    <+ python-backend-option
    <+ java-servlet-backend-option
    <+ stage-option
    <+ session-timeout-option
    <+ webdsl-verbose-option
    <+ disable-typecheck-option
    <+ only-typecheck-option
    <+ extra-typecheck-option
    <+ disable-pretty-print-option
    <+ format-java-code-option
    <+ webdsl-statistics-option
    <+ webdsl-debug-option
    <+ webdsl-test-option
    <+ webdsl-version-option
    <+ debug-print-source-tree-option
    <+ debug-print-backend-tree-option
    <+ caching-option
    <+ build-id-option
    <+ index-dir-option
    <+ webdsl-compile-built-ins-option
    <+ webdsl-custom-compile-units-option
    <+ webdsl-compile-units-cache-option
    <+ jrebel-option
    <+ show-optimization-warning-option
    <+ print-optimizations-option
    <+ query-optimization-option
    <+ postgres-option
    <+ debug-ac-option
    <+ webdsl-inlining-option
    <+ app-statistics-option

  // @todo check that verbosity and logging is supported by stratego-lib

  // @todo code for option definition is too boilerplate

strategies // desugaring
	
  webdsl-version-option =
    Option("--version"
    , rules( WebDSLShowVersion := True() )
    , !HelpString("--version", "Show version information.")
    )

  python-backend-option =
    Option("--python"
    , rules( PythonBackend := True() )
    , !HelpString("--python", "Use Python back-end.")
    )

  java-servlet-backend-option =
    Option("--servlet"
    , rules(JavaServletBackend := True())
    , !HelpString("--servlet", "Use Java Servlet back-end.")
    )

  webdsl-debug-option =
    Option("--debug"
    , rules ( WebDSLDebug := True() )
    , !HelpString("--debug", "Enable debug info during execution of the web application")
    )

  if-debug(s) = if where(WebDSLDebug) then s end

  session-timeout-option =
    ArgOption("--session-timeout"
    , ?time; rules( SessionTimeout := time )
    , !HelpString("--session-timeout n", "Set session timeout to n minutes")
    )

  stage-option =
    ArgOption("--stop-after"
    , ?stage; rules( OptionStage := <string-to-int> stage )
    , !HelpString("--stop-after n", "Stop after stage n")
    )

  caching-option =
    ArgOption("--enable-caching"
    , ?caching; try(<eq> (caching, "1"); rules(CachingEnabled := True()))
    , !HelpString("--enable-caching i", "Enable (1) or disable (0, default) caching")
    )

  build-id-option =
    ArgOption("--build-id"
    , ?buildid; rules( BuildIdOption := buildid )
    , !HelpString("--build-id n", "Set build id to n, is shown on a page by appending '?show_build_id=true' to an URL. Used for detecting deployment state.")
    )

  build-id-request-var-name = !"show_build_id"

strategies

  webdsl-compile-built-ins-option =
    Option("--compile-built-ins"
    , rules ( WebDSLCompileBuiltIns := True() )
    , !HelpString("--compile-built-ins", "Generate code for built-in definitions")
    )

strategies

  webdsl-custom-compile-units-option =
    Option("--custom-compile-units"
    , rules ( WebDSLCustomCompileUnits := True() )
    , !HelpString("--custom-compile-units", "experimental separate compilation for advanced users")
    )

  is-custom-compile-units-enabled = WebDSLCustomCompileUnits; not(WebDSLCompileBuiltIns)

strategies

  webdsl-compile-units-cache-option =
    Option("--compile-units-cache"
    , rules ( WebDSLCompileUnitsCache := True() )
    , !HelpString("--compile-units-cache", "experimental separate compilation for advanced users")
    )

  is-compile-units-cache-enabled =
    WebDSLCompileUnitsCache
  ; not(WebDSLCompileBuiltIns)

  is-compile-units-cache-stale = WebDSLCompileUnitsCacheDisable

  disable-compile-units-cache = rules( WebDSLCompileUnitsCacheDisable := True() ) // in case of entity changes

strategies

  // application.ini inlinetemplates=true option is set

  webdsl-inlining-option =
    Option("--inlinetemplates"
    , rules ( WebDSLTemplateInliningEnabled := True() )
    , !HelpString("--inlinetemplates", "experimental template inlining")
    )

  is-template-inlining-enabled =
    WebDSLTemplateInliningEnabled
  ; not(WebDSLCompileBuiltIns)

strategies

  webdsl-test-option =
    Option("--test"
    , rules ( WebDSLTest := True() )
    , !HelpString("--test", "Set up application for local testing")
    )

  if-test(s) = if where(WebDSLTest) then s end

  if-test : content -> result
    with  if WebDSLTest
          then result := content
          else result := []
          end

  if-not-test: content -> result
    with  if not(WebDSLTest)
          then result := content
          else result := []
          end

strategies //verbosity

  webdsl-verbose-option =
    ArgOption("--verbose"
    , ?level; rules( VerbosityLevel := <string-to-int> level ); <string-to-int; set-verbosity> level
    , !HelpString("--verbose n", "Set verbosity level, 0: show only errors, 1: show phase times and errors (default), 2: show all")
    )

  verbose-1(s) = if where(<geq> (<VerbosityLevel>, 1)) then s end
  verbose-2(s) = if where(<geq> (<VerbosityLevel>, 2)) then s end
  is-verbose-2 = <geq> (<VerbosityLevel>, 2)
  if-verbose-2(s) = if where(is-verbose-2) then s end

strategies //no pretty printing

  disable-pretty-print-option =
    Option("--no-pretty-printing" + "--no-pp"
    , disable-pretty-printing
    , !HelpString("--no-pretty-printing | --no-pp", "Do not pretty-print")
    )

  disable-pretty-printing =
    rules( OptionPrettyPrinting := False() )

  if-pretty-printing(s1, s2) =
    if not(OptionPrettyPrinting => False()) then s1 else s2 end

strategies //enable java code formatting with Box pretty-printing

  format-java-code-option =
    Option("--format-java-code"
    , enable-box-pretty-printing
    , !HelpString("--format-java-code", "pretty-print Java code with indentation (slower)")
    )

  enable-box-pretty-printing =
    rules( OptionBoxPrettyPrinting := True() )

  if-box-pretty-printing(s1, s2) =
    if OptionBoxPrettyPrinting => True() then s1 else s2 end

strategies //statistics

  webdsl-statistics-option =
    Option("--statistics"
    , show-statistics
    , !HelpString("--statistics", "show detailed time statistics")
    )

  show-statistics =
    rules( OptionStatistics := True() )

  if-statistics(s1, s2) =
    if OptionStatistics => True() then s1 else s2 end

strategies

  app-statistics-option =
    Option("--app-statistics"
    , rules( OptionAppStatistics := True() )
    , !HelpString("--app-statistics", "Only print application statistics")
    )

strategies //no typechecking

  disable-typecheck-option =
    Option("--no-typechecking"
    , disable-typechecking
    , !HelpString("--no-typechecking", "Ignore all type errors")
    )

  disable-typechecking =
    rules( OptionTypecheck := False() )

  if-typechecking(s1, s2) =
    if OptionTypecheck => True() then s1 else s2 end

strategies //only typechecking

  only-typecheck-option =
    Option("--typecheck"
    , only-typechecking
    , !HelpString("--typecheck", "Perform only typechecking, useful for editor support")
    )

  only-typechecking =
    rules( OptionOnlyTypecheck := True() )

  if-only-typechecking(s1, s2) =
    if OptionOnlyTypecheck => True() then s1 else s2 end
  if-only-typechecking(s1) =
    if OptionOnlyTypecheck => True() then s1 end

strategies //extra typechecking after model-to-model

  extra-typecheck-option =
    Option("--extra-typecheck"
    , extra-typechecking
    , !HelpString("--extra-typecheck", "Perform typechecking after model-to-model transformations")
    )

  extra-typechecking =
    rules( OptionExtraTypecheck := True() )

  if-extra-typechecking(s1, s2) =
    if OptionExtraTypecheck => True() then s1 else s2 end
  if-extra-typechecking(s1) =
    if OptionExtraTypecheck => True() then s1 end

strategies

  webdsl-version-option =
    Option("--version"
    , rules(WebDSLShowVersion := <get-webdsl-version>)
    , !HelpString("--version", "Show WebDSL version")
    )

  get-webdsl-version = prim("PACKAGE_VERSION_TERM")


strategies    // debug options

  debug-print-source-tree-option =
    Option("--print-source-tree"
    , rules(DebugPrintSourceTree : x -> x)
    , !HelpString("--print-source-tree", "Print entire AST after parsing.")
    )

  debug-print-backend-tree-option =
    Option("--print-backend-tree"
    , rules(DebugPrintBackendTree : x -> x)
    , !HelpString("--print-backend-tree", "Print entire AST as it enters the backend.")
    )

strategies 	// search options
  index-dir-option =
      ArgOption("--indexdir"
      , ?dir; rules( IndexDir := dir )
      , !HelpString("--indexdir x", "Set working directory to x.")
      )

strategies  // query optimization options

  show-optimization-warning-option =
    Option("--show-optimization-warnings"
    , rules(NotOptimizedWarnings := True())
    , !HelpString("--show-optimization-warnings", "Show optimization warnings")
    )

  print-optimizations-option =
    Option("--print-optimizations"
    , rules(PrintOptimizations := True())
    , !HelpString("--print-optimizations", "Show generated optimizations")
    )

  query-optimization-option =
    ArgOption("--enable-query-optimization"
    , rules (QueryOptimizationMode := GuidedBatchingNoJoins()); try(define-optimization-mode)
    , !HelpString("--enable-query-optimization i", "Choose optimization mode (1, default) or disable query optimization (0)")
    )

  define-optimization-mode =
    where(
      ?optimization
      ; (<eq> (optimization, "0") <+ <eq> (optimization, "false"))
      ; rules(
          QueryOptimizationDisabled := True()
          QueryOptimizationMode := NoQueryOptimization()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; (<eq> (optimization, "1") <+ <eq> (optimization, "true"))
      ; rules(
          QueryOptimizationMode := GuidedBatchingNoJoins()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; <eq> (optimization, "2")
      ; rules(
          QueryOptimizationMode := GuidedBatchingJoins()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; <eq> (optimization, "3")
      ; rules(
          QueryOptimizationMode := GuidedBatchingFixedSize()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; <eq> (optimization, "4")
      ; rules(
          QueryOptimizationDisabled := True()
          QueryOptimizationMode := HibernateBatching()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; <eq> (optimization, "5")
      ; rules(
          QueryOptimizationDisabled := True()
          QueryOptimizationMode := HibernateSubselect()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; <eq> (optimization, "6")
      ; rules(
          QueryOptimizationDisabled := True()
          QueryOptimizationMode := HibernateSubselectWithBatching()
        )
    )

  define-optimization-mode =
    where(
      ?optimization
      ; <eq> (optimization, "7")
      ; rules(
          QueryOptimizationMode := AtArguments()
        )
    )
    
  debug-ac-option = 
    Option("--debugac"
    , rules (DebugAC := True() )
    , !HelpString("--debugac", "Visualize access control guards by surrounding borders.")
    )
  
  is-debug-ac = where(DebugAC)
   
strategies 	// database options
	
  postgres-option =
    Option("--postgres"
    , rules ( Postgres := True() )
    , !HelpString("--postgres", "Use Hibernate data type mappings for PostgreSQL.")
    )

  is-postgres = where(Postgres)