rails.gradle

/*
 * Copyright 2022 Thoughtworks, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import com.thoughtworks.go.build.ExecuteUnderRailsTask
import com.thoughtworks.go.build.InstallerType
import com.thoughtworks.go.build.YarnInstallTask
import com.thoughtworks.go.build.YarnRunTask
import groovy.text.SimpleTemplateEngine
import groovy.text.Template
import org.apache.tools.ant.types.Commandline
import org.gradle.internal.jvm.Jvm

task pathingJar(type: Jar) {
  archiveClassifier = 'pathing'
  dependsOn(project.railsTasksDefaultDependsOn)

  doFirst {
    manifest {
      attributes 'Class-Path': (project.railsClasspath.files - [project.configurations.compileClasspath.files { it.name == 'jruby-complete' }.first()]).collect { it.toURI() }.join(' ')
    }
  }
}

task generateJSRoutes(type: ExecuteUnderRailsTask) {
  outputs.cacheIf { true }
  onlyIf { !project.hasProperty('fastBuild') }
  def outputDir = file("${project.railsRoot}/webpack/gen")
  inputs.dir(file("${project.railsRoot}/vendor"))
  inputs.files(fileTree(dir: "${project.railsRoot}/config", includes: ['**/*.rb']))
  outputs.dir(outputDir)

  environment(
    'RAILS_ENV': 'production',
    'RAILS_GROUPS': 'assets',
    'OUTPUT_DIR': outputDir,
  )

  args = ['-S', 'rake', '--trace', 'generated_js']

  doFirst {
    delete outputDir
  }
}

task createJRubyBinstubs {
  outputs.cacheIf { true }
  def outputDir = file("scripts")
  inputs.dir("script-templates")
  inputs.properties([
    bundledGemDir: project.bundledGemDir,
    railsRoot: project.railsRoot
  ])

  def jrubyJar = project.configurations.compileClasspath.files { it.name == 'jruby-complete' }.first()

  def templateProperties = [
    mainClassName       : 'org.jruby.Main',
    jvmArgs             : project.jrubyOptimizationJvmArgs,
    systemProperties    : (project.jrubyOptimizationSystemProperties + project.jrubyDefaultSystemProperties + project.railsSystemProperties),
    classpath           : [pathingJar.archiveFile.get().asFile],
    jrubyJar            : jrubyJar,
    environment         : project.defaultJRubyEnvironment,
    additionalJRubyPaths: project.additionalJRubyPaths,
    javaExecutable      : Jvm.current().getExecutable("java")
  ]

  inputs.properties(templateProperties)
  outputs.dir(outputDir)

  doFirst {
    project.delete(outputDir)
    project.mkdir(outputDir)

    ['jgem', 'rspec', 'ruby', 'gem'].each { file ->
      copy {
        from "script-templates/${file}"
        into outputDir
        eachFile { FileCopyDetails fcp ->
          fcp.mode = 0755
        }
      }
    }

    ['jruby', 'jruby.bat'].each { eachFile ->
      def inputTemplate = file("script-templates/${eachFile}")
      def engine = new SimpleTemplateEngine()
      Template template = engine.createTemplate(inputTemplate)
      String output = template.make(templateProperties).toString()

      file("${outputDir}/${inputTemplate.name}").write(output)
      file("${outputDir}/${inputTemplate.name}").setExecutable(true)
    }
  }
}

task initializeRailsGems {
  outputs.cacheIf { true }
  dependsOn createJRubyBinstubs
  inputs.file("${project.railsRoot}/Gemfile")
  inputs.file("${project.railsRoot}/Gemfile.lock")
  inputs.file("${project.railsRoot}/.bundle/config")
  inputs.properties([
    jrubyVersion: project.deps.jruby,
    bundledGemDir: project.bundledGemDir,
    railsRoot: project.railsRoot
  ])

  outputs.dir(project.bundledGemDir)

  doFirst {
    project.jrubyexec {
      workingDir = project.railsRoot
      args = ['-S', 'bundle', 'install']
      maxHeapSize = '1g'
    }
  }
}

task yarnInstall(type: YarnInstallTask) {
  // delete this in the compile phase, because otherwise the yarnInstall detects a new folder and reinstalls.
  project.delete(project.file("${project.railsRoot}/node_modules/.cache"))
  workingDir = project.railsRoot
}

prepare.dependsOn(initializeRailsGems, createJRubyBinstubs, yarnInstall)

task cleanRails(type: Delete) {
  delete "${buildDir}/railsTests"
  delete "${project.railsRoot}/config/cipher"
  delete "${project.railsRoot}/config/cipher.aes"
  delete "${project.railsRoot}/db/config.git"
  delete "${project.railsRoot}/db/h2db"
  delete "${project.railsRoot}/logs"
  delete "${project.railsRoot}/node_modules"
  delete "${project.railsRoot}/public/assets"
  delete "${project.railsRoot}/tmp"
  delete "${project.railsRoot}/webpack/gen"
  delete "${project.railsRoot}/yarn-error.log"

  doFirst {
    // these are purposely added as `doFirst` to avoid intellij from excluding these from the modules
    project.delete project.jrubyScriptsDir
    project.delete project.bundledGemDir
  }
}
clean.dependsOn cleanRails

task compileAssetsWebpackDev(type: YarnRunTask) {
  dependsOn yarnInstall
  dependsOn generateJSRoutes

  onlyIf { !project.hasProperty('fastBuild') }

  ext.licenseReportFile = project.file("${project.buildDir}/reports/yarn-license/license-report.json")
  outputs.dir(ext.licenseReportFile.parentFile)

  source(project.file("${project.railsRoot}/webpack"))
  source(project.file("${project.railsRoot}/vendor/assets"))
  source(project.file("${project.railsRoot}/config"))

  workingDir = project.railsRoot
  destinationDir = project.file("${project.railsRoot}/public/assets/webpack")
  yarnCommand = ['webpack-dev', '--env', "outputDir=${destinationDir.toPath().toString()}", '--env', "licenseReportFile=${ext.licenseReportFile}"]
}

task compileAssetsWebpackProd(type: YarnRunTask) {
  dependsOn yarnInstall
  dependsOn generateJSRoutes

  onlyIf { !project.hasProperty('fastBuild') }

  ext.licenseReportFile = project.file("${project.buildDir}/reports/yarn-license/license-report.json")
  outputs.dir(ext.licenseReportFile.parentFile)

  source(project.file("${project.railsRoot}/webpack"))
  source(project.file("${project.railsRoot}/vendor/assets"))
  source(project.file("${project.railsRoot}/config"))

  workingDir = project.railsRoot
  destinationDir = project.file("${project.buildDir}/webpack-assets")
  yarnCommand = ['webpack-prod', '--env', "outputDir=${destinationDir.toPath().toString()}", '--env', "licenseReportFile=${ext.licenseReportFile}"]
}

task compileAssetsRailsTest(type: ExecuteUnderRailsTask) {
  dependsOn yarnInstall
  outputs.cacheIf { true }
  onlyIf { !project.hasProperty('fastBuild') }

  def publicAssetsDir = file("${project.railsRoot}/public/assets")

  inputs.dir(file("${project.railsRoot}/config"))
  inputs.dir(file("${project.railsRoot}/app/assets/config"))
  inputs.dir(file("${project.railsRoot}/app/assets/javascripts"))
  inputs.dir(file("${project.railsRoot}/vendor/assets/javascripts"))

  outputs.dir(publicAssetsDir)

  environment += [
    'RAILS_ENV' : 'test',
    'RAILS_GROUPS': 'assets',
  ]

  // Native-subprocess control is needed for usage of Dart Sass via sass-embedded
  jvmArgs += [
    '--add-opens=java.base/sun.nio.ch=ALL-UNNAMED',
    '--add-opens=java.base/java.io=ALL-UNNAMED'
  ]

  args = ['-S', 'rake', '--trace', 'assets:clobber', 'assets:precompile']

  doFirst {
    delete "${project.railsRoot}/tmp"
    delete publicAssetsDir
    publicAssetsDir.parentFile.mkdirs()
  }
}

task compileAssetsRailsProd(type: ExecuteUnderRailsTask) {
  dependsOn yarnInstall
  outputs.cacheIf { true }
  onlyIf { !project.hasProperty('fastBuild') }

  def outputAssetsDir = file("${project.buildDir}/rails-assets")
  def publicAssetsDir = file("${project.railsRoot}/public/assets")

  inputs.dir(file("${project.railsRoot}/config"))
  inputs.dir(file("${project.railsRoot}/app/assets"))
  inputs.dir(file("${project.railsRoot}/vendor/assets"))

  outputs.dir(outputAssetsDir)

  disableJRubyOptimization = true

  environment(
    'RAILS_ENV': 'production',
    'RAILS_GROUPS': 'assets',
  )

  // Native-subprocess control is needed for usage of Dart Sass via sass-embedded
  jvmArgs += [
    '--add-opens=java.base/sun.nio.ch=ALL-UNNAMED',
    '--add-opens=java.base/java.io=ALL-UNNAMED'
  ]

  args = ['-S', 'rake', '--trace', 'assets:clobber', 'assets:precompile']

  doFirst {
    delete "${project.railsRoot}/tmp"
    delete outputAssetsDir
    outputAssetsDir.parentFile.mkdirs()
  }

  doLast {
    copy {
      from publicAssetsDir
      into outputAssetsDir
    }

    delete publicAssetsDir
  }
}

task compileAssets {
  dependsOn compileAssetsWebpackProd
  dependsOn licenseReportAggregate
  dependsOn compileAssetsRailsProd
  inputs.files licenseReportAggregate.outputs.files
  inputs.files compileAssetsRailsProd.outputs.files
  inputs.files compileAssetsWebpackProd.outputs.files

  def outputDir = project.file("${project.buildDir}/assets")
  outputs.dir(outputDir)

  onlyIf { !project.hasProperty('fastBuild') }

  doFirst {
    delete outputDir

    copy {
      from licenseReportAggregate
      // assets are cached with a long lived cache header
      // we purposefully add a version string in the path so every new build will basically use a different url
      into "${outputDir}/dependency-license-report-${project.version}"
    }
    copy {
      from compileAssetsRailsProd
      into outputDir
    }
    copy {
      from compileAssetsWebpackProd
      into "${outputDir}/webpack"
    }
  }
}

task rspec(type: ExecuteUnderRailsTask) {
  dependsOn yarnInstall
  outputs.cacheIf { true }
  inputs.files project.railsRoot
  inputs.files project.railsClasspath

  description = "Run specs (pass '-Popts=...' to pass options)"

  disableJRubyOptimization = true

  environment += [
    'REPORTS_DIR': "${project.buildDir}/rspec-results"
  ]

  jvmArgs += InstallerType.server.jvmModuleOpensArgs + ['-XX:+HeapDumpOnOutOfMemoryError', "-XX:HeapDumpPath=${project.buildDir}/heap-dumps"]
  args = ['-S', 'rspec', '--backtrace']
  maxHeapSize = '2g'

  if (project.hasProperty('opts')) {
    args += Commandline.translateCommandline(project.property('opts')) as List<String>
  }

  doFirst {
    project.mkdir("${project.buildDir}/heap-dumps")
    project.file("${project.buildDir}/heap-dumps/foo.txt").setText("")
  }
}

task parallelRspec(type: ExecuteUnderRailsTask) {
  dependsOn yarnInstall
  outputs.cacheIf { true }
  inputs.files project.railsRoot
  inputs.files project.railsClasspath

  description = "Run specs (pass '-Popts=...' to pass options)"

  disableJRubyOptimization = true

  environment += [
    'REPORTS_DIR': "${project.buildDir}/rspec-results"
  ]

  jvmArgs += InstallerType.server.jvmModuleOpensArgs + ['-XX:+HeapDumpOnOutOfMemoryError', "-XX:HeapDumpPath=${project.buildDir}/heap-dumps"]
  args = ['-S', 'rspec', '--backtrace']
  maxHeapSize = '2g'

  if (project.hasProperty('opts')) {
    args += Commandline.translateCommandline(project.property('opts')) as List<String>
  }

  doFirst {
    project.mkdir("${project.buildDir}/heap-dumps")
    project.file("${project.buildDir}/heap-dumps/foo.txt").setText("")
  }

  doFirst {
    FileTree tree = fileTree(dir: "${project.railsRoot}/spec", includes: ['**/*_spec.rb'])
    def files = partitionFiles(tree.files)

    args += files.collect { project.railsRoot.toURI().relativize(it.toURI()).getPath() }

    if (project.hasProperty('opts')) {
      args += Commandline.translateCommandline(project.property('opts')) as List<String>
    }
  }
}

task railsExec(type: ExecuteUnderRailsTask) {
  outputs.upToDateWhen { false }

  description = "rails exec (pass '-Pcmd=...' to pass options)"

  args = Commandline.translateCommandline(project.properties.get('cmd')) as List<String>
}