getPassword()
58 |
59 | /**
60 | * {@link CopySpec} content to add into repository.
61 | *
62 | * contents {
63 | * from 'src/pages'
64 | * from(javadoc) {
65 | * into 'api'
66 | * }
67 | * }
68 | *
69 | * @see gradle docs
70 | */
71 | CopySpec contents
72 | /**
73 | * What to keep (or remote) in existing branch.
74 | * E.g. to keep version 1.0.0 files except temp.txt file:
75 | *
76 | * preserve {
77 | * include '1.0.0/**'
78 | * exclude '1.0.0/temp.txt'
79 | * }
80 | *
81 | *
82 | * By default, only ".git" folder preserved.
83 | *
84 | * @see
85 | * gradle doc
86 | */
87 | PatternFilterable preserve
88 |
89 | GitPublishExtension(Project project) {
90 | this.contents = project.copySpec()
91 | this.preserve = new PatternSet()
92 | this.preserve.include('.git/**/*')
93 | }
94 |
95 | void contents(Action action) {
96 | action.execute(contents)
97 | }
98 |
99 | void preserve(Action action) {
100 | action.execute(preserve)
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/MkdocsBuildPlugin.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import groovy.transform.CompileStatic
4 | import groovy.transform.TypeCheckingMode
5 | import org.gradle.api.Plugin
6 | import org.gradle.api.Project
7 | import ru.vyarus.gradle.plugin.mkdocs.task.MkdocsBuildTask
8 | import ru.vyarus.gradle.plugin.mkdocs.task.MkdocsInitTask
9 | import ru.vyarus.gradle.plugin.mkdocs.task.MkdocsTask
10 | import ru.vyarus.gradle.plugin.python.PythonExtension
11 | import ru.vyarus.gradle.plugin.python.PythonPlugin
12 |
13 | /**
14 | * Base mkdocs plugin without publishing tasks (and so without grgit plugin registration). May be used in cases when
15 | * publication is not required or when there are problems with grgit plugin.
16 | *
17 | * Provides tasks:
18 | *
19 | * - mkdocsInit - create documentation site
20 | *
- mkdocsBuild - build site
21 | *
- mkdocsServe - start livereload server (for development)
22 | *
23 | *
24 | * mkdocksInit not use 'mkdocs new', instead more advanced template used with pre-initialized material theme.
25 | *
26 | * Plugin will also apply all required pip modules to use mkdocks with material theme and basic plugins
27 | * (see {@link ru.vyarus.gradle.plugin.mkdocs.MkdocsExtension#DEFAULT_MODULES}).
28 | *
29 | * @author Vyacheslav Rusakov
30 | * @since 28.10.2022
31 | */
32 | @CompileStatic
33 | class MkdocsBuildPlugin implements Plugin {
34 |
35 | private static final List STRICT = ['-s']
36 | private static final String DEV_ADDR = '--dev-addr'
37 |
38 | public static final String MKDOCS_BUILD_TASK = 'mkdocsBuild'
39 | public static final String DOCUMENTATION_GROUP = 'documentation'
40 |
41 | @Override
42 | void apply(Project project) {
43 | MkdocsExtension extension = project.extensions.create('mkdocs', MkdocsExtension, project)
44 |
45 | project.plugins.apply(PythonPlugin)
46 | applyDefaults(project)
47 | configureMkdocsTasks(project, extension)
48 | configureServe(project, extension)
49 | }
50 |
51 | private void applyDefaults(Project project) {
52 | // apply default mkdocs, material and minimal plugins
53 | // user will be able to override versions, if required
54 | project.extensions.getByType(PythonExtension).pip(MkdocsExtension.DEFAULT_MODULES)
55 | }
56 |
57 | @SuppressWarnings('AbcMetric')
58 | private void configureMkdocsTasks(Project project, MkdocsExtension extension) {
59 | project.tasks.register(MKDOCS_BUILD_TASK, MkdocsBuildTask) { task ->
60 | task.description = 'Build mkdocs documentation'
61 | task.group = DOCUMENTATION_GROUP
62 | task.extraArgs.convention project.provider { extension.strict ? STRICT : [] }
63 | task.outputDir.convention(project.file("${getBuildOutputDir(extension)}"))
64 | task.updateSiteUrl.convention(extension.updateSiteUrl)
65 | task.versionPath.convention(extension.resolveDocPath())
66 | task.versionName.convention(extension.resolveVersionTitle())
67 | task.rootRedirectPath
68 | .convention(extension.publish.rootRedirect ? extension.resolveRootRedirectionPath() : null)
69 | task.versionAliases.convention(extension.publish.versionAliases
70 | ? extension.publish.versionAliases as List : [])
71 | task.buildDir.convention(project.file(extension.buildDir))
72 | task.existingVersionFile.convention(extension.publish.existingVersionsFile)
73 | }
74 |
75 | project.tasks.register('mkdocsInit', MkdocsInitTask) { task ->
76 | task.description = 'Create mkdocs documentation'
77 | task.group = DOCUMENTATION_GROUP
78 | task.sourcesDir.convention(extension.sourcesDir)
79 | }
80 |
81 | project.tasks.withType(MkdocsTask).configureEach { task ->
82 | task.workDir.convention(extension.sourcesDir)
83 | task.sourcesDir.convention(extension.sourcesDir)
84 | task.extras.convention(project.provider {
85 | // resolving lazy gstrings ("${-> something}") because they can't be serialized
86 | Map res = [:]
87 | extension.extras.each {
88 | res.put(it.key, it.value?.toString())
89 | }
90 | res
91 | })
92 | }
93 |
94 | // simplify direct task usage
95 | project.extensions.extraProperties.set(MkdocsTask.simpleName, MkdocsTask)
96 | }
97 |
98 | @CompileStatic(TypeCheckingMode.SKIP)
99 | private void configureServe(Project project, MkdocsExtension extension) {
100 | project.tasks.register('mkdocsServe', MkdocsTask) { task ->
101 | task.description = 'Start mkdocs live reload server'
102 | task.group = DOCUMENTATION_GROUP
103 | task.command.set('serve')
104 | if (dockerUsed) {
105 | // mkdocs in strict mode does not allow external mappings, so avoid strict, event if configured
106 | // also ip must be changed, otherwise server would be invisible outside docker
107 | task.extraArgs DEV_ADDR, "0.0.0.0:${extension.devPort}"
108 | } else {
109 | List args = extension.strict ? new ArrayList<>(STRICT) : []
110 | args += [DEV_ADDR, "127.0.0.1:${extension.devPort}"]
111 | task.extraArgs.addAll(args)
112 | }
113 | // docker activation is still up to global configuration - here just required tuning
114 | // task would be started in exclusive container in order to stream output immediately
115 | task.docker.exclusive.set(true)
116 | task.docker.ports extension.devPort
117 | }
118 | }
119 |
120 | private String getBuildOutputDir(MkdocsExtension extension) {
121 | return extension.buildDir + (extension.multiVersion ? '/' + extension.resolveDocPath() : '')
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/service/GrgitService.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.service
2 |
3 | import groovy.transform.CompileStatic
4 | import org.ajoberstar.grgit.Grgit
5 | import org.gradle.api.services.BuildService
6 | import org.gradle.api.services.BuildServiceParameters
7 | import org.gradle.tooling.events.FinishEvent
8 | import org.gradle.tooling.events.OperationCompletionListener
9 |
10 | /**
11 | * Git service to manage single grgit instance between publish tasks.
12 | *
13 | * @author Vyacheslav Rusakov
14 | * @since 09.04.2024
15 | */
16 | @CompileStatic
17 | @SuppressWarnings(['AbstractClassWithoutAbstractMethod', 'ConfusingMethodName'])
18 | abstract class GrgitService implements BuildService,
19 | OperationCompletionListener, AutoCloseable {
20 |
21 | /**
22 | * Grgit instance. Initiated by gitReset task and used by other git tasks.
23 | */
24 | Grgit grgit
25 |
26 | @Override
27 | @SuppressWarnings('EmptyMethodInAbstractClass')
28 | void onFinish(FinishEvent finishEvent) {
29 | // not used, just to keep service alive
30 | }
31 |
32 | @Override
33 | void close() throws Exception {
34 | if (grgit != null) {
35 | grgit.close()
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/source/RepoUriValueSource.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.source
2 |
3 | import groovy.transform.CompileStatic
4 | import org.ajoberstar.grgit.Configurable
5 | import org.ajoberstar.grgit.Grgit
6 | import org.ajoberstar.grgit.operation.OpenOp
7 | import org.gradle.api.provider.Property
8 | import org.gradle.api.provider.ValueSource
9 | import org.gradle.api.provider.ValueSourceParameters
10 |
11 | /**
12 | * Git repository detection in project root. Custom value source is required for configuration cache support because
13 | * all external processes must be wrapped (even if this values could be easily cached).
14 | *
15 | * @author Vyacheslav Rusakov
16 | * @since 10.04.2024
17 | */
18 | @CompileStatic
19 | @SuppressWarnings('AbstractClassWithoutAbstractMethod')
20 | abstract class RepoUriValueSource implements ValueSource {
21 |
22 | @SuppressWarnings(['UnnecessaryCast', 'CatchException'])
23 | String obtain() {
24 | try {
25 | Grgit repo = Grgit.open({ OpenOp op -> op.dir = parameters.rootDir.get() } as Configurable)
26 | return repo.remote.list().find { it.name == 'origin' }?.url
27 | } catch (Exception ignored) {
28 | // repository not initialized case - do nothing (most likely user is just playing with the plugin)
29 | }
30 | return null
31 | }
32 |
33 | interface Params extends ValueSourceParameters {
34 | Property getRootDir()
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/task/MkdocsBuildTask.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import groovy.transform.CompileStatic
4 | import groovy.transform.TypeCheckingMode
5 | import org.apache.tools.ant.taskdefs.condition.Os
6 | import org.gradle.api.GradleException
7 | import org.gradle.api.file.Directory
8 | import org.gradle.api.provider.ListProperty
9 | import org.gradle.api.provider.Property
10 | import org.gradle.api.provider.Provider
11 | import org.gradle.api.tasks.*
12 | import ru.vyarus.gradle.plugin.mkdocs.MkdocsExtension
13 | import ru.vyarus.gradle.plugin.mkdocs.util.MkdocsConfig
14 | import ru.vyarus.gradle.plugin.mkdocs.util.TemplateUtils
15 | import ru.vyarus.gradle.plugin.mkdocs.util.VersionsFileUtils
16 |
17 | /**
18 | * Builds mkdocs site. If version is configured as default for publication, then generate extra index.html.
19 | * If mkdocs.yml contains site_url value then current path will applied in config (original config reverted after
20 | * the build).
21 | *
22 | * @author Vyacheslav Rusakov
23 | * @since 14.11.2017
24 | */
25 | @CompileStatic
26 | @SuppressWarnings(['DuplicateStringLiteral', 'AbstractClassWithoutAbstractMethod',
27 | 'AbstractClassWithPublicConstructor'])
28 | abstract class MkdocsBuildTask extends MkdocsTask {
29 |
30 | private static final String SITE_URL = 'site_url'
31 |
32 | /**
33 | * Output directory.
34 | */
35 | @OutputDirectory
36 | abstract Property getOutputDir()
37 |
38 | /**
39 | * Update 'site_url' in mkdocs configuration to correct path. Required for multi-version publishing to
40 | * correctly update version url.
41 | */
42 | @Input
43 | abstract Property getUpdateSiteUrl()
44 |
45 | /**
46 | * Version directory path. "." if no version directories used.
47 | * @see {@link ru.vyarus.gradle.plugin.mkdocs.MkdocsExtension.Publish#docPath}
48 | */
49 | @Input
50 | abstract Property getVersionPath()
51 |
52 | /**
53 | * Version name (what to show in version dropdown).
54 | * @see {@link ru.vyarus.gradle.plugin.mkdocs.MkdocsExtension.Publish#versionTitle}
55 | */
56 | @Input
57 | @Optional
58 | abstract Property getVersionName()
59 |
60 | /**
61 | * Root redirection path or null to disable root redirection.
62 | */
63 | @Input
64 | @Optional
65 | abstract Property getRootRedirectPath()
66 |
67 | /**
68 | * Version aliases.
69 | */
70 | @Input
71 | @Optional
72 | abstract ListProperty getVersionAliases()
73 |
74 | /**
75 | * Mkdocs build directory.
76 | */
77 | @OutputDirectory
78 | abstract Property getBuildDir()
79 |
80 | /**
81 | * Versions file to update (when publish tasks not used).
82 | */
83 | @Input
84 | @Optional
85 | abstract Property getExistingVersionFile()
86 |
87 | @Internal
88 | Provider projectBuildDir = project.layout.buildDirectory
89 |
90 | MkdocsBuildTask() {
91 | command.set(project.provider {
92 | boolean isWindows = Os.isFamily(Os.FAMILY_WINDOWS)
93 | String path = outputDir.get().canonicalPath
94 | if (isWindows) {
95 | // always wrap into quotes for windows
96 | path = "\"$path\""
97 | }
98 | // use array to avoid escaping spaces in path (and consequent args parsing)
99 | return ['build', '-c', '-d', path]
100 | })
101 | }
102 |
103 | @Override
104 | void run() {
105 | String path = versionPath.get()
106 | boolean multiVersion = path != MkdocsExtension.SINGLE_VERSION_PATH
107 | Closure action = { super.run() }
108 |
109 | if (updateSiteUrl.get() && multiVersion) {
110 | // update mkdocs.yml site_url from global to published folder (in order to build correct sitemap)
111 | withModifiedConfig(path, action)
112 | } else {
113 | action.call()
114 | }
115 |
116 | // output directory must be owned by current user, not root, otherwise clean would fail
117 | dockerChown(outputDir.get().toPath())
118 |
119 | // optional remote versions file update
120 | updateVersions()
121 |
122 | if (multiVersion) {
123 | // add root index.html
124 | copyRedirect(path)
125 | copyAliases(path)
126 | }
127 | }
128 |
129 | @InputDirectory
130 | File getSourcesDirectory() {
131 | return fs.file(sourcesDir.get())
132 | }
133 |
134 | private void withModifiedConfig(String path, Closure action) {
135 | MkdocsConfig conf = new MkdocsConfig(fs, sourcesDir.get())
136 | String url = conf.find(SITE_URL)
137 |
138 | // site_url not defined or already points to correct location
139 | if (!url || url.endsWith(path) || url.endsWith("$path/")) {
140 | action.call()
141 | return
142 | }
143 |
144 | File backup = conf.backup()
145 | try {
146 | String slash = '/'
147 | String folderUrl = (url.endsWith(slash) ? url : (url + slash)) + path
148 | conf.set(SITE_URL, folderUrl)
149 | logger.lifecycle("Modified ${fs.relativePath(conf.config)}: '$SITE_URL: $folderUrl'")
150 | action.call()
151 | } finally {
152 | conf.restoreBackup(backup)
153 | logger.lifecycle("Original ${fs.relativePath(conf.config)} restored")
154 | }
155 | }
156 |
157 | private void updateVersions() {
158 | String versions = existingVersionFile.orNull
159 | if (versions) {
160 | File target
161 | if (versions.contains(':')) {
162 | target = new File(projectBuildDir.get().asFile, 'old-versions.json')
163 | download(versions, target)
164 | } else {
165 | target = fs.file(versions)
166 | }
167 | File res = VersionsFileUtils.getTarget(buildDir.get())
168 | logger.lifecycle('Creating versions file: {}', fs.relativePath(res))
169 | Map> parse = VersionsFileUtils.parse(target)
170 | if (target.exists()) {
171 | logger.lifecycle("\tExisting versions file '{}' loaded with {} versions", versions, parse.size())
172 | } else {
173 | logger.warn("\tWARNING: configured versions file '{}' does not exist - creating new file instead",
174 | versions)
175 | }
176 |
177 | String currentVersion = versionPath.get()
178 | if (VersionsFileUtils.addVersion(parse, currentVersion)) {
179 | logger.lifecycle('\tNew version added: {}', currentVersion)
180 | }
181 | VersionsFileUtils.updateVersion(parse,
182 | currentVersion, versionName.get(), versionAliases.get())
183 | VersionsFileUtils.write(parse, res)
184 | logger.lifecycle('\tVersions written to file: {}', parse.keySet().join(', '))
185 | }
186 | }
187 |
188 | @CompileStatic(TypeCheckingMode.SKIP)
189 | private void download(String src, File target) {
190 | // ignore all errors (create new file if failed to load)
191 | ant.get(src: src, dest: target, maxtime: 5, skipexisting: true, ignoreerrors: true)
192 | }
193 |
194 | private void copyRedirect(String path) {
195 | if (rootRedirectPath.orNull) {
196 | String target = rootRedirectPath.get()
197 | List possible = [path]
198 | possible.addAll(versionAliases.get())
199 | if (!possible.contains(target)) {
200 | throw new GradleException("Invalid mkdocs.publish.rootRedirectTo option value: '$target'. " +
201 | "Possible values are: ${possible.join(', ')} ('\$docPath' for actual version)")
202 | }
203 | // create root redirection file
204 | TemplateUtils.copy(fs, '/ru/vyarus/gradle/plugin/mkdocs/template/publish/',
205 | fs.relativePath(buildDir.get()), [docPath: target])
206 | logger.lifecycle('Root redirection enabled to: {}', target)
207 | } else {
208 | // remove stale index.html (to avoid unintentional redirect override)
209 | // of course, build always must be called after clean, but at least minimize damage on incorrect usage
210 | File index = new File(buildDir.get(), 'index.html')
211 | if (index.exists()) {
212 | index.delete()
213 | }
214 | }
215 | }
216 |
217 | @CompileStatic(TypeCheckingMode.SKIP)
218 | private void copyAliases(String version) {
219 | File baseDir = buildDir.get()
220 |
221 | List aliases = versionAliases.get()
222 | if (aliases) {
223 | aliases.each { String alias ->
224 | fs.copy { spec ->
225 | spec.from new File(baseDir, version)
226 | spec.into new File(baseDir, alias)
227 | }
228 | }
229 | logger.lifecycle('Version aliases added: {}', aliases.join(', '))
230 | }
231 | }
232 | }
233 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/task/MkdocsInitTask.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import groovy.transform.CompileStatic
4 | import org.gradle.api.DefaultTask
5 | import org.gradle.api.GradleException
6 | import org.gradle.api.internal.file.FileOperations
7 | import org.gradle.api.provider.Property
8 | import org.gradle.api.provider.Provider
9 | import org.gradle.api.tasks.Input
10 | import org.gradle.api.tasks.TaskAction
11 | import ru.vyarus.gradle.plugin.mkdocs.util.TemplateUtils
12 |
13 | import javax.inject.Inject
14 |
15 | /**
16 | * Generate initial mkdocs site. Does not use "mkdocs new" command. Custom template is used instead in order
17 | * to pre-configure target site with the material theme and enable some extensions.
18 | *
19 | * @author Vyacheslav Rusakov
20 | * @since 13.11.2017
21 | */
22 | @CompileStatic
23 | abstract class MkdocsInitTask extends DefaultTask {
24 |
25 | /**
26 | * Documentation sources folder (mkdocs sources root folder).
27 | */
28 | @Input
29 | abstract Property getSourcesDir()
30 |
31 | protected Provider projectName = project.provider { project.name }
32 | protected Provider projectDesc = project.provider { project.description }
33 |
34 | @TaskAction
35 | void run() {
36 | String sourcesPath = sourcesDir.get()
37 | File dir = fs.file(sourcesPath)
38 | if (dir.exists() && dir.listFiles().length > 0) {
39 | throw new GradleException("Can't init new mkdocs site because target directory is not empty: $dir")
40 | }
41 |
42 | TemplateUtils.copy(fs, '/ru/vyarus/gradle/plugin/mkdocs/template/init/', dir, [
43 | projectName: projectName.get(),
44 | projectDescription: projectDesc.orNull ?: '',
45 | docDir: sourcesPath,
46 | ])
47 | logger.lifecycle("Mkdocs site initialized: $sourcesPath")
48 | }
49 |
50 | @Inject
51 | protected abstract FileOperations getFs()
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/task/MkdocsTask.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import groovy.transform.CompileStatic
4 | import org.gradle.api.GradleException
5 | import org.gradle.api.internal.file.FileOperations
6 | import org.gradle.api.provider.MapProperty
7 | import org.gradle.api.provider.Property
8 | import org.gradle.api.tasks.Input
9 | import ru.vyarus.gradle.plugin.mkdocs.util.MkdocsConfig
10 | import ru.vyarus.gradle.plugin.python.task.PythonTask
11 |
12 | import javax.inject.Inject
13 |
14 | /**
15 | * General mkdocs task.
16 | *
17 | * Provides support for gradle-driven variables. When variables be declared in {@code mkdocs.extras} map,
18 | * task would generate special data file: {@code [mkdocs.yml location]/docs/_data/gradle.yml}.
19 | * Markdownextradata plugin must be activated in mkdocs.yml (exception will be thrown if not). Plugin searches
20 | * by default in @{code [mkdocs.yml location]/docs/_data/} dir for variable files (no magic behaviour).
21 | * In documentation variables may be used as
{{ gradle.var_name }}.
22 | *
23 | * @author Vyacheslav Rusakov
24 | * @since 13.11.2017
25 | * @see markdownextradata plugin documentation
26 | */
27 | @CompileStatic
28 | @SuppressWarnings(['AbstractClassWithoutAbstractMethod', 'AbstractClassWithPublicConstructor'])
29 | abstract class MkdocsTask extends PythonTask {
30 |
31 | MkdocsTask() {
32 | // restrict commands to mkdocs module
33 | module.set('mkdocs')
34 | }
35 |
36 | /**
37 | * Documentation sources folder (mkdocs sources root folder).
38 | */
39 | @Input
40 | abstract Property getSourcesDir()
41 |
42 | /**
43 | * Extra gradle-provided variables to use in documentation.
44 | */
45 | @Input
46 | abstract MapProperty getExtras()
47 |
48 | @Override
49 | @SuppressWarnings('UnnecessaryGetter')
50 | void run() {
51 | if (extras.get().isEmpty()) {
52 | // no vars - simple run
53 | super.run()
54 | } else {
55 | runWithVariables()
56 | }
57 | }
58 |
59 | @Inject
60 | protected abstract FileOperations getFs()
61 |
62 | private void runWithVariables() {
63 | File data = resolveDataDir()
64 | boolean removeDataDir = !data.exists()
65 | File gen = new File(data, 'gradle.yml')
66 | try {
67 | if (removeDataDir) {
68 | data.mkdirs()
69 | }
70 | // assuming this file owned by gradle exclusively and may remain only because of incorrect task shutdown
71 | if (gen.exists()) {
72 | gen.delete()
73 | }
74 | logger.lifecycle('Generating mkdocs data file: {}', getFilePath(gen))
75 | String report = ''
76 | gen.withWriter { BufferedWriter writer ->
77 | extras.get().each { k, v ->
78 | // Object value used for deferred evaluation (GString may use lazy placeholders)
79 | String line = k.replaceAll('[ -]', '_') + ': ' + (v ?: '')
80 | writer.writeLine(line)
81 | report += "\t$line\n"
82 | }
83 | }
84 | logger.lifecycle(report)
85 | super.run()
86 | } finally {
87 | gen.delete()
88 | if (removeDataDir) {
89 | data.delete()
90 | }
91 | }
92 | }
93 |
94 | private File resolveDataDir() {
95 | MkdocsConfig config = new MkdocsConfig(fs, sourcesDir.get())
96 |
97 | if (!config.contains('plugins.markdownextradata')) {
98 | throw new GradleException(
99 | 'Gradle-defined extra properties require \'markdownextradata\' plugin active in ' +
100 | 'your mkdocs.yml file, which is currently not the case. \nEither remove extra properties ' +
101 | 'declaration (in build.gradle) or declare plugin (in mkdocs.yml) like this: \n' +
102 | 'plugins:\n' +
103 | ' - search\n' +
104 | ' - markdownextradata')
105 | }
106 |
107 | // mkdocs.yml location
108 | File root = fs.file(sourcesDir.get())
109 |
110 | // configuration may override default "docs" location
111 | String docsPath = config.find('docs_dir') ?: 'docs'
112 | File docs = new File(docsPath)
113 | // docs_dir config value may contain absolute path declaration
114 | if (!docs.absolute) {
115 | docs = new File(root, docs.path)
116 | }
117 |
118 | return new File(docs, '_data')
119 | }
120 |
121 | /**
122 | * Looks if file inside project and relative path would be reasonable, otherwise return absolute path.
123 | *
124 | * @param file file
125 | * @return relative or absolute file path
126 | */
127 | private String getFilePath(File file) {
128 | if (file.path.startsWith(gradleEnv.get().rootDir.path)) {
129 | return fs.relativePath(file)
130 | }
131 | return file.absolutePath
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/task/publish/GitPublishCommit.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task.publish
2 |
3 | import groovy.transform.CompileStatic
4 | import org.ajoberstar.grgit.Configurable
5 | import org.ajoberstar.grgit.Grgit
6 | import org.ajoberstar.grgit.operation.AddOp
7 | import org.ajoberstar.grgit.operation.CommitOp
8 | import org.gradle.api.DefaultTask
9 | import org.gradle.api.Task
10 | import org.gradle.api.provider.Property
11 | import org.gradle.api.specs.Spec
12 | import org.gradle.api.tasks.*
13 | import ru.vyarus.gradle.plugin.mkdocs.service.GrgitService
14 |
15 | import java.util.stream.Collectors
16 | import java.util.stream.Stream
17 |
18 | /**
19 | * Git commit task. Based on https://github.com/ajoberstar/gradle-git-publish.
20 | *
21 | * @author Vyacheslav Rusakov
22 | * @since 08.04.2024
23 | */
24 | @CompileStatic
25 | @SuppressWarnings('AbstractClassWithPublicConstructor')
26 | abstract class GitPublishCommit extends DefaultTask {
27 |
28 | /**
29 | * Commit message.
30 | */
31 | @Input
32 | abstract Property getMessage()
33 |
34 | /**
35 | * Signing commits. Omit to use the default from your gitconfig.
36 | */
37 | @Input
38 | @Optional
39 | abstract Property getSign()
40 |
41 | // grgit instance initiated under reset task
42 | @Internal
43 | abstract Property getGrgit()
44 |
45 | GitPublishCommit() {
46 | // always consider this task out of date
47 | this.outputs.upToDateWhen({ t -> false } as Spec)
48 | }
49 |
50 | @OutputDirectory
51 | File getRepoDirectory() {
52 | return grgit.get().grgit.repository.rootDir
53 | }
54 |
55 | @TaskAction
56 | void commit() {
57 | Grgit git = grgit.get().grgit
58 | git.add({ AddOp op ->
59 | op.patterns = Stream.of('.').collect(Collectors.toSet())
60 | } as Configurable)
61 |
62 | // check if anything has changed
63 | if (git.status().clean) {
64 | didWork = false
65 | } else {
66 | git.commit({ CommitOp op ->
67 | op.message = message.get()
68 | if (sign.present) {
69 | op.sign = sign.get()
70 | }
71 | } as Configurable)
72 | didWork = true
73 | }
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/task/publish/GitPublishPush.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task.publish
2 |
3 | import groovy.transform.CompileStatic
4 | import org.ajoberstar.grgit.BranchStatus
5 | import org.ajoberstar.grgit.Configurable
6 | import org.ajoberstar.grgit.Grgit
7 | import org.ajoberstar.grgit.operation.BranchChangeOp
8 | import org.ajoberstar.grgit.operation.BranchStatusOp
9 | import org.ajoberstar.grgit.operation.PushOp
10 | import org.gradle.api.DefaultTask
11 | import org.gradle.api.Task
12 | import org.gradle.api.provider.Property
13 | import org.gradle.api.specs.Spec
14 | import org.gradle.api.tasks.Input
15 | import org.gradle.api.tasks.Internal
16 | import org.gradle.api.tasks.OutputDirectory
17 | import org.gradle.api.tasks.TaskAction
18 | import ru.vyarus.gradle.plugin.mkdocs.service.GrgitService
19 |
20 | /**
21 | * Git push task. Based on https://github.com/ajoberstar/gradle-git-publish.
22 | *
23 | * @author Vyacheslav Rusakov
24 | * @since 08.04.2024
25 | */
26 | @CompileStatic
27 | @SuppressWarnings('AbstractClassWithPublicConstructor')
28 | abstract class GitPublishPush extends DefaultTask {
29 |
30 | /**
31 | * Target branch (would be created if doesn't exists).
32 | */
33 | @Input
34 | abstract Property getBranch()
35 |
36 | // grgit instance initiated under reset task
37 | @Internal
38 | abstract Property getGrgit()
39 |
40 | GitPublishPush() {
41 | // always consider this task out of date
42 | this.outputs.upToDateWhen({ t -> false } as Spec)
43 | // NOTE: onlyIf removed due to conflicts with configuration cache so task would never be up to date
44 | }
45 |
46 | @OutputDirectory
47 | File getRepoDirectory() {
48 | return grgit.get().grgit.repository.rootDir
49 | }
50 |
51 | @TaskAction
52 | void push() {
53 | Grgit git = grgit.get().grgit
54 | // moved from onlyIf to avoid calling git under configuration stage
55 | if (!isPushRequired(git)) {
56 | return
57 | }
58 | String pubBranch = branch.get()
59 | git.push({ PushOp op ->
60 | op.refsOrSpecs = Arrays.asList(String.format('refs/heads/%s:refs/heads/%s', pubBranch, pubBranch))
61 | } as Configurable)
62 | // ensure tracking is set
63 | git.branch.change({ BranchChangeOp op ->
64 | op.name = pubBranch
65 | op.startPoint = 'origin/' + pubBranch
66 | op.mode = BranchChangeOp.Mode.TRACK
67 | } as Configurable)
68 | }
69 |
70 | private boolean isPushRequired(Grgit git) {
71 | try {
72 | BranchStatus status = git.branch.status({ BranchStatusOp op ->
73 | op.name = branch.get()
74 | } as Configurable)
75 | return status.aheadCount > 0
76 | } catch (IllegalStateException e) {
77 | // if we're not tracking anything yet (i.e. orphan) we need to push
78 | return true
79 | }
80 | }
81 | }
82 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/util/MkdocsConfig.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.util
2 |
3 | import groovy.transform.CompileStatic
4 | import org.gradle.api.GradleException
5 | import org.gradle.api.internal.file.FileOperations
6 |
7 | import java.util.regex.Matcher
8 |
9 | /**
10 | * Utility to work with mkdocs config (mkdocs.yml).
11 | *
12 | * @author Vyacheslav Rusakov
13 | * @since 07.12.2017
14 | */
15 | @CompileStatic
16 | class MkdocsConfig {
17 |
18 | private final FileOperations fs
19 | private final String configLocation
20 |
21 | MkdocsConfig(FileOperations fs, String sourceDir) {
22 | this.fs = fs
23 | this.configLocation = (sourceDir ? "$sourceDir/" : '') + 'mkdocs.yml'
24 | }
25 |
26 | /**
27 | * @return mkdocs config file
28 | * @throws GradleException if config does not exist
29 | */
30 | File getConfig() {
31 | File config = fs.file(configLocation)
32 | if (!config.exists()) {
33 | throw new GradleException("Mkdocs config file not found: ${fs.relativePath(config)}")
34 | }
35 | return config
36 | }
37 |
38 | /**
39 | * @param option config option to find
40 | * @return option value or null if option commented or not defined
41 | */
42 | String find(String option) {
43 | String line = config.readLines().find {
44 | it.startsWith("$option:")
45 | }
46 | if (line) {
47 | int pos = line.indexOf(':')
48 | // special case: no value defined on property
49 | String res = pos < line.length() - 1 ? line[pos + 1..-1].trim() : ''
50 | // remove quotes
51 | return res.replaceAll(/^['"]/, '').replaceAll(/['"]$/, '')
52 | }
53 | return null
54 | }
55 |
56 | /**
57 | * Searches for specified property. Supports nesting: if property contains dots then it will search for
58 | * each property part sequentially (note that multiline list value also counted as property).
59 | *
60 | * Looks only not commented lines. Counts hierarchy.
61 | *
62 | * @param option option (maybe composite: separated with dots) name to find
63 | * @return true is string found, false otherwise
64 | */
65 | boolean contains(String option) {
66 | String[] parts = option.split('\\.')
67 | int i = 0
68 | int whitespace = 0
69 | String line = config.readLines().find {
70 | // line must not be commented, contain enough whitespace and required option part
71 | // allowed: [ prop, prop:, - prop, -prop ]
72 | if (!it.trim().startsWith('#') && it.find(
73 | /${whitespace == 0 ? '^' : '\\s{' + whitespace + ',}'}(-\s{0,})?${parts[i]}(:|$|\s)/)) {
74 | if (whitespace == 0) {
75 | whitespace++
76 | } else {
77 | // count starting whitespace (to correctly recognize structure)
78 | Matcher matcher = it =~ /^(\s+)/
79 | if (!matcher.find()) {
80 | throw new IllegalStateException("Failed to recognize preceeding whitespace in '$it'")
81 | }
82 | whitespace = matcher.group(1).length() + 1
83 | }
84 | i++
85 | }
86 | return i == parts.length
87 | }
88 | return line != null
89 | }
90 |
91 | /**
92 | * Replace option value in mkdocks config.
93 | *
94 | * @param option option name
95 | * @param value new option value
96 | */
97 | void set(String option, String value) {
98 | config.text = config.text.replaceAll(/(?m)^$option:.*/, "$option: $value")
99 | }
100 |
101 | /**
102 | * Backup configuration file.
103 | *
104 | * @return configuration backup file
105 | */
106 | File backup() {
107 | File backup = new File(config.parentFile, 'mkdocs.yml.bak')
108 | if (backup.exists()) {
109 | backup.delete()
110 | }
111 | backup << config.text
112 | return backup
113 | }
114 |
115 | /**
116 | * Replace current configuration file with provided backup.
117 | *
118 | * @param backup configuration backup
119 | * @throws IllegalStateException if backup file or config does not exists
120 | */
121 | void restoreBackup(File backup) {
122 | if (!backup.exists()) {
123 | throw new IllegalStateException("No backup file found: ${fs.relativePath(backup)}")
124 | }
125 | File cfg = config
126 | cfg.delete()
127 | if (!backup.renameTo(cfg)) {
128 | throw new IllegalStateException("Failed to rename ${fs.relativePath(backup.absolutePath)} back " +
129 | "to ${fs.relativePath(cfg.absolutePath)}. Please rename manually to recover.")
130 | }
131 | }
132 | }
133 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/util/TemplateUtils.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.util
2 |
3 | import groovy.transform.CompileStatic
4 | import groovy.transform.TypeCheckingMode
5 | import org.apache.tools.ant.filters.ReplaceTokens
6 | import org.gradle.api.file.FileCopyDetails
7 | import org.gradle.api.file.FileTree
8 | import org.gradle.api.internal.file.FileOperations
9 |
10 | /**
11 | * Utility to extract templates from classpath (plugin jar) and copy to target location with placeholders processing.
12 | *
13 | * @author Vyacheslav Rusakov
14 | * @since 05.12.2017
15 | */
16 | @CompileStatic
17 | class TemplateUtils {
18 |
19 | private static final String SLASH = '/'
20 |
21 | /**
22 | * Copies templates from classpath (inside the jar) with placeholders substitution.
23 | *
24 | * @param fs file operations
25 | * @param path path to folder on classpath to copy (path must start with '/')
26 | * @param to target location (string, File)
27 | * @param tokens substitution tokens
28 | */
29 | @CompileStatic(TypeCheckingMode.SKIP)
30 | static void copy(FileOperations fs, String path, Object to, Map tokens) {
31 | URL folder = getUrl(path)
32 | FileTree tree
33 | boolean isJar = folder.toString().startsWith('jar:')
34 | if (isJar) {
35 | tree = fs.zipTree(getJarUrl(folder))
36 | } else {
37 | tree = fs.fileTree(folder)
38 | }
39 |
40 | fs.copy { spec ->
41 | spec.from tree
42 | spec.into to
43 | if (isJar) {
44 | spec.include pathToWildcard(path)
45 | // cut off path
46 | spec.eachFile { FileCopyDetails f ->
47 | f.path = f.path.replaceFirst(pathToCutPrefix(path), '')
48 | }
49 | spec.includeEmptyDirs = false
50 | }
51 | spec.filter(ReplaceTokens, tokens: tokens)
52 | }
53 | }
54 |
55 | private static URL getUrl(String path) {
56 | if (!path.startsWith(SLASH)) {
57 | throw new IllegalArgumentException("Path must be absolute (start with '/'): $path")
58 | }
59 | URL folder = TemplateUtils.getResource(path)
60 | if (folder == null) {
61 | // workaround for tests
62 | folder = Thread.currentThread().contextClassLoader.getResource(path.replaceAll('^/', ''))
63 | }
64 | if (folder == null) {
65 | throw new IllegalArgumentException("No resources found on path: $path")
66 | }
67 | return folder
68 | }
69 |
70 | private static URL getJarUrl(URL fileUrl) {
71 | return ((JarURLConnection) fileUrl.openConnection()).jarFileURL
72 | }
73 |
74 | private static String pathToWildcard(String path) {
75 | return (path.endsWith(SLASH) ? path : path + SLASH) + '**'
76 | }
77 |
78 | private static String pathToCutPrefix(String path) {
79 | String res = path[1..-1]
80 | return res.endsWith(SLASH) ? res : res + SLASH
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/src/main/groovy/ru/vyarus/gradle/plugin/mkdocs/util/VersionsFileUtils.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.util
2 |
3 | import groovy.json.JsonOutput
4 | import groovy.json.JsonSlurper
5 | import groovy.transform.CompileStatic
6 |
7 | /**
8 | * Versions file utilities.
9 | *
10 | * @author Vyacheslav Rusakov
11 | * @since 30.10.2022
12 | */
13 | @CompileStatic
14 | class VersionsFileUtils {
15 |
16 | static final String VERSIONS_FILE = 'versions.json'
17 | static final String ALIASES = 'aliases'
18 |
19 | private static final Comparator VERSIONS_COMPARATOR = VersionsComparator.comparingVersions(false)
20 |
21 | /**
22 | * @param file versions file to parse
23 | * @return parsed versions or empty map
24 | */
25 | static Map> parse(File file) {
26 | // self-sorted
27 | Map> res =
28 | new TreeMap>(VERSIONS_COMPARATOR.reversed())
29 |
30 | if (file.exists()) {
31 | ((List>) new JsonSlurper().parse(file))
32 | .each { ver -> res.put((String) ver['version'], ver) }
33 | }
34 | return res
35 | }
36 |
37 | /**
38 | * @param file versions structure
39 | * @param version version to add
40 | * @return true if version added, false if version already present
41 | */
42 | @SuppressWarnings('SpaceAroundMapEntryColon')
43 | static boolean addVersion(Map> file, String version) {
44 | boolean added = false
45 | if (!file.containsKey(version)) {
46 | file.put(version, ['version': version,
47 | 'title' : version,
48 | (ALIASES): [],])
49 | added = true
50 | }
51 | return added
52 | }
53 |
54 | /**
55 | * Updates version title and aliases (plus, removes used aliases from other versions).
56 | *
57 | * @param file versions structure
58 | * @param version taret version
59 | * @param title version title
60 | * @param aliases version aliases (may be null)
61 | */
62 | static void updateVersion(Map> file,
63 | String version, String title, List aliases) {
64 | // remove current version aliases from all versions (avoid alias duplication)
65 | if (aliases) {
66 | file.values().each {
67 | List als = it[ALIASES] as List
68 | als.removeAll(aliases)
69 | }
70 | }
71 | // update custom title (to handle case when existing version re-generated)
72 | file.get(version).with {
73 | it.put('title', title)
74 | it.put(VersionsFileUtils.ALIASES, aliases as String[] ?: [])
75 | }
76 | }
77 |
78 | /**
79 | * @param buildDir mkdocs build dir
80 | * @return versions file in mkdocs build directory
81 | */
82 | static File getTarget(File buildDir) {
83 | return new File(buildDir, VERSIONS_FILE)
84 | }
85 |
86 | /**
87 | * Writes versions structure into version file (overriding its content).
88 | *
89 | * @param file version structure
90 | * @param target target file
91 | */
92 | static void write(Map> file, File target) {
93 | List> res = []
94 | // map was sorted
95 | res.addAll(file.values())
96 |
97 | String json = JsonOutput.toJson(res)
98 | // create parent dirs
99 | target.parentFile.mkdirs()
100 | target.newWriter().withWriter { w ->
101 | w << json
102 | }
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
/src/main/resources/ru/vyarus/gradle/plugin/mkdocs/template/init/docs/about/history.md:
--------------------------------------------------------------------------------
1 | ### 1.0.0 (2017.11.01)
2 |
3 | * Initial release
--------------------------------------------------------------------------------
/src/main/resources/ru/vyarus/gradle/plugin/mkdocs/template/init/docs/guide/installation.md:
--------------------------------------------------------------------------------
1 | # Installation
2 |
3 | To install do...
--------------------------------------------------------------------------------
/src/main/resources/ru/vyarus/gradle/plugin/mkdocs/template/init/docs/index.md:
--------------------------------------------------------------------------------
1 | # Welcome to MkDocs
2 |
3 | * [mkdocs documentation](http://mkdocs.org).
4 | * [mkdocs-material documentation](https://squidfunk.github.io/mkdocs-material/).
5 |
6 | ## Project layout
7 |
8 | mkdocs.yml # The configuration file.
9 | docs/
10 | index.md # The documentation homepage.
11 | ... # Other markdown pages, images and other files.
12 |
13 | ## Gradle tasks
14 |
15 | * `mkdocsInit` - Create new mkdocs site (like this).
16 | * `mkdocsBuild` - Build the documentation site.
17 | * `mkdocsServe` - Start the live-reloading docs server.
18 | * `mkdocsPublish` - Publish generated site version to github pages.
19 |
20 | ## Mkdocs native Commands
21 |
22 | * `mkdocs new [dir-name]` - Create a new project.
23 | * `mkdocs serve` - Start the live-reloading docs server.
24 | * `mkdocs build` - Build the documentation site.
25 | * `mkdocs help` - Print this help message.
--------------------------------------------------------------------------------
/src/main/resources/ru/vyarus/gradle/plugin/mkdocs/template/init/mkdocs.yml:
--------------------------------------------------------------------------------
1 | site_name: @projectName@
2 |
3 | # Meta tags (placed in header)
4 | site_description: @projectDescription@
5 | #site_author: Your Name
6 | site_url: # https://you.github.io/@projectName@
7 |
8 | # Repository (add link to repository on each page)
9 | #repo_name: @projectName@
10 | #repo_url: http://github.com/you/@projectName@
11 | #edit_uri: edit/master/@docDir@/docs/
12 |
13 | #Copyright (shown at the footer)
14 | #copyright: 'Copyright © 2017 Your Name'
15 |
16 | # Meterial theme
17 | theme:
18 | name: 'material'
19 | palette:
20 | - media: "(prefers-color-scheme: light)"
21 | scheme: default
22 | toggle:
23 | icon: material/toggle-switch-off-outline
24 | name: Switch to dark mode
25 | - media: "(prefers-color-scheme: dark)"
26 | scheme: slate
27 | toggle:
28 | icon: material/toggle-switch
29 | name: Switch to light mode
30 | features:
31 | #- navigation.tabs
32 | #- navigation.tabs.sticky
33 | #- navigation.instant
34 | - navigation.tracking
35 | - navigation.top
36 |
37 | #plugins:
38 | # - search
39 | # Required for variables support (https://github.com/rosscdh/mkdocs-markdownextradata-plugin)
40 | # - markdownextradata
41 |
42 | #extra:
43 | # palette:
44 | # primary: 'indigo'
45 | # accent: 'indigo'
46 |
47 | # version:
48 | # provider: mike
49 |
50 | # social:
51 | # - icon: fontawesome/brands/github
52 | # link: https://github.com/you
53 | # - icon: fontawesome/brands/twitter
54 | # link: https://twitter.com/you
55 | #
56 | # Google Analytics
57 | # analytics:
58 | # provider: google
59 | # property: UA-XXXXXXXX-X
60 |
61 | markdown_extensions:
62 | # Python Markdown
63 | - abbr
64 | - admonition
65 | - attr_list
66 | - def_list
67 | - footnotes
68 | - meta
69 | - md_in_html
70 | - toc:
71 | permalink: true
72 |
73 | # Python Markdown Extensions
74 | - pymdownx.arithmatex:
75 | generic: true
76 | - pymdownx.betterem:
77 | smart_enable: all
78 | - pymdownx.caret
79 | - pymdownx.details
80 | - pymdownx.emoji:
81 | emoji_index: !!python/name:material.extensions.emoji.twemoji
82 | emoji_generator: !!python/name:material.extensions.emoji.to_svg
83 | - pymdownx.highlight
84 | - pymdownx.inlinehilite
85 | - pymdownx.keys
86 | - pymdownx.mark
87 | - pymdownx.smartsymbols
88 | - pymdownx.superfences
89 | - pymdownx.tabbed:
90 | alternate_style: true
91 | - pymdownx.tasklist:
92 | custom_checkbox: true
93 | - pymdownx.tilde
94 |
95 | nav:
96 | - Home: index.md
97 | - User guide:
98 | - Installation: guide/installation.md
99 | - About:
100 | - Release notes: about/history.md
--------------------------------------------------------------------------------
/src/main/resources/ru/vyarus/gradle/plugin/mkdocs/template/publish/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/AbstractKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.apache.tools.ant.taskdefs.condition.Os
4 | import org.gradle.testkit.runner.BuildResult
5 | import org.gradle.testkit.runner.GradleRunner
6 | import spock.lang.Specification
7 | import spock.lang.TempDir
8 |
9 | /**
10 | * Base class for Gradle TestKit based tests.
11 | * Useful for full-cycle and files manipulation testing.
12 | *
13 | * @author Vyacheslav Rusakov
14 | * @since 29.10.2017
15 | */
16 | abstract class AbstractKitTest extends Specification {
17 |
18 | boolean debug
19 | boolean isWin = Os.isFamily(Os.FAMILY_WINDOWS)
20 |
21 | @TempDir File testProjectDir
22 | File buildFile
23 |
24 | def setup() {
25 | buildFile = file('build.gradle')
26 | // jacoco coverage support
27 | fileFromClasspath('gradle.properties', 'testkit-gradle.properties')
28 | }
29 |
30 | def build(String file) {
31 | buildFile << file
32 | }
33 |
34 | File file(String path) {
35 | new File(testProjectDir, path)
36 | }
37 |
38 | File fileFromClasspath(String toFile, String source) {
39 | File target = file(toFile)
40 | target.parentFile.mkdirs()
41 | target.withOutputStream {
42 | it.write((getClass().getResourceAsStream(source) ?: getClass().classLoader.getResourceAsStream(source)).bytes)
43 | }
44 | target
45 | }
46 |
47 | /**
48 | * Enable it and run test with debugger (no manual attach required). Not always enabled to speed up tests during
49 | * normal execution.
50 | */
51 | def debug() {
52 | debug = true
53 | }
54 |
55 | String projectName() {
56 | return testProjectDir.getName()
57 | }
58 |
59 | GradleRunner gradle(File root, String... commands) {
60 | GradleRunner.create()
61 | .withProjectDir(root)
62 | .withArguments((commands + ['--stacktrace']) as String[])
63 | .withPluginClasspath()
64 | .withDebug(debug)
65 | .forwardOutput()
66 | }
67 |
68 | GradleRunner gradle(String... commands) {
69 | gradle(testProjectDir, commands)
70 | }
71 |
72 | BuildResult run(String... commands) {
73 | return gradle(commands).build()
74 | }
75 |
76 | BuildResult runFailed(String... commands) {
77 | return gradle(commands).buildAndFail()
78 | }
79 |
80 | BuildResult runVer(String gradleVersion, String... commands) {
81 | println 'Running with GRADLE ' + gradleVersion
82 | return gradle(commands).withGradleVersion(gradleVersion).build()
83 | }
84 |
85 | BuildResult runFailedVer(String gradleVersion, String... commands) {
86 | println 'Running with GRADLE ' + gradleVersion
87 | return gradle(commands).withGradleVersion(gradleVersion).buildAndFail()
88 | }
89 |
90 | protected String unifyString(String input) {
91 | return input
92 | // cleanup win line break for simpler comparisons
93 | .replace("\r", '')
94 | }
95 | }
96 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/AbstractTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.apache.tools.ant.taskdefs.condition.Os
4 | import org.gradle.api.Project
5 | import org.gradle.testfixtures.ProjectBuilder
6 | import spock.lang.Specification
7 | import spock.lang.TempDir
8 |
9 | /**
10 | * Base class for plugin configuration tests.
11 | *
12 | * @author Vyacheslav Rusakov
13 | * @since 29.10.2017
14 | */
15 | abstract class AbstractTest extends Specification{
16 |
17 | boolean isWin = Os.isFamily(Os.FAMILY_WINDOWS)
18 |
19 | @TempDir File testProjectDir
20 |
21 | Project project(Closure config = null) {
22 | projectBuilder(config).build()
23 | }
24 |
25 | ExtendedProjectBuilder projectBuilder(Closure root = null) {
26 | new ExtendedProjectBuilder().root(testProjectDir, root)
27 | }
28 |
29 | File file(String path) {
30 | new File(testProjectDir, path)
31 | }
32 |
33 | File fileFromClasspath(String toFile, String source) {
34 | File target = file(toFile)
35 | target.parentFile.mkdirs()
36 | target << getClass().getResourceAsStream(source).text
37 | }
38 |
39 | static class ExtendedProjectBuilder {
40 | Project root
41 |
42 | ExtendedProjectBuilder root(File dir, Closure config = null) {
43 | assert root == null, "Root project already declared"
44 | Project project = ProjectBuilder.builder()
45 | .withProjectDir(dir).build()
46 | if (config) {
47 | project.configure(project, config)
48 | }
49 | root = project
50 | return this
51 | }
52 |
53 | /**
54 | * Direct child of parent project
55 | *
56 | * @param name child project name
57 | * @param config optional configuration closure
58 | * @return builder
59 | */
60 | ExtendedProjectBuilder child(String name, Closure config = null) {
61 | return childOf(null, name, config)
62 | }
63 |
64 | /**
65 | * Direct child of any registered child project
66 | *
67 | * @param projectRef name of required parent module (gradle project reference format: `:some:deep:module`)
68 | * @param name child project name
69 | * @param config optional configuration closure
70 | * @return builder
71 | */
72 | ExtendedProjectBuilder childOf(String projectRef, String name, Closure config = null) {
73 | assert root != null, "Root project not declared"
74 | Project parent = projectRef == null ? root : root.project(projectRef)
75 | File folder = parent.file(name)
76 | if (!folder.exists()) {
77 | folder.mkdir()
78 | }
79 | Project project = ProjectBuilder.builder()
80 | .withName(name)
81 | .withProjectDir(folder)
82 | .withParent(parent)
83 | .build()
84 | if (config) {
85 | project.configure(project, config)
86 | }
87 | return this
88 | }
89 |
90 | /**
91 | * Evaluate configuration.
92 | *
93 | * @return root project
94 | */
95 | Project build() {
96 | if (root.subprojects) {
97 | linkSubprojectsEvaluation(root)
98 | }
99 | root.evaluate()
100 | return root
101 | }
102 |
103 | private void linkSubprojectsEvaluation(Project project) {
104 | project.evaluationDependsOnChildren()
105 | project.subprojects.each { linkSubprojectsEvaluation(it) }
106 | }
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/ConfigurationCacheSupportPushKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import groovy.json.JsonSlurper
4 | import org.ajoberstar.grgit.Grgit
5 | import org.gradle.testkit.runner.BuildResult
6 | import org.gradle.testkit.runner.TaskOutcome
7 | import spock.lang.TempDir
8 |
9 | /**
10 | * @author Vyacheslav Rusakov
11 | * @since 10.04.2024
12 | */
13 | class ConfigurationCacheSupportPushKitTest extends AbstractKitTest {
14 |
15 | @TempDir File repoDir
16 |
17 | Grgit repo
18 |
19 | @Override
20 | def setup() {
21 | // local repo used for push
22 | println 'init fake gh-pages repo'
23 | repo = Grgit.init(dir: repoDir, bare: true)
24 | assert repo.branch.list().size() == 0
25 | // connect with project folder
26 | println 'associate project with fake repo'
27 | Grgit prjRepo = Grgit.init(dir: testProjectDir)
28 | prjRepo.remote.add(name: 'origin', url: repoDir.canonicalPath, pushUrl: repoDir.canonicalPath)
29 | // init remote repo
30 | file('readme.txt') << 'sample'
31 | prjRepo.add(patterns: ['*'])
32 | prjRepo.commit(message: 'initial commit')
33 | prjRepo.push()
34 | prjRepo.close()
35 |
36 | assert repo.log().size() == 1
37 | assert repo.branch.list().size() == 1
38 | }
39 |
40 | void cleanup() {
41 | repo.close()
42 | }
43 |
44 | def "Check default publish"() {
45 |
46 | setup:
47 | build """
48 | plugins {
49 | id 'ru.vyarus.mkdocs'
50 | }
51 |
52 | version = '1.0'
53 |
54 | python.scope = USER
55 | """
56 |
57 | when: "run init"
58 | BuildResult result = run('--configuration-cache', '--configuration-cache-problems=warn', 'mkdocsInit')
59 |
60 | then: "no configuration cache incompatibilities"
61 | result.output.contains("1 problem was found storing the configuration cache")
62 | result.output.contains('Gradle runtime: support for using a Java agent with TestKit')
63 | result.output.contains('Calculating task graph as no cached configuration is available for tasks:')
64 |
65 | then: "docs created"
66 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
67 | file('src/doc/mkdocs.yml').exists()
68 |
69 | when: "publish"
70 | result = run('--configuration-cache', '--configuration-cache-problems=warn', 'mkdocsPublish')
71 |
72 | then: "no configuration cache incompatibilities"
73 | result.output.contains("1 problem was found storing the configuration cache")
74 | result.output.contains('Gradle runtime: support for using a Java agent with TestKit')
75 | result.output.contains('Calculating task graph as no cached configuration is available for tasks:')
76 |
77 | then: "published"
78 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
79 | repo.branch.list().size() == 2
80 |
81 | then: "content available"
82 | file('/.gradle/gh-pages/1.0/index.html').exists()
83 | file('/.gradle/gh-pages/index.html').exists()
84 |
85 | then: "versions file correct"
86 | result.output.contains("Versions file generated with 1 versions:")
87 | file('/.gradle/gh-pages/versions.json').exists()
88 | with(new JsonSlurper().parse(file('/.gradle/gh-pages/versions.json')) as List) {
89 | it.size() == 1
90 | it[0]['title'] == '1.0'
91 | }
92 |
93 |
94 | when: "publish another version"
95 | buildFile.delete()
96 | build """
97 | plugins {
98 | id 'ru.vyarus.mkdocs'
99 | }
100 |
101 | version = '1.1'
102 |
103 | python.scope = USER
104 | """
105 | result = run('--configuration-cache', '--configuration-cache-problems=warn', 'mkdocsPublish')
106 |
107 | then: "cache used"
108 | result.output.contains('Calculating task graph as configuration cache cannot be reused because file \'build.gradle\' has changed.')
109 |
110 | then: "version published"
111 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
112 | file('/.gradle/gh-pages/1.1/index.html').exists()
113 | file('/.gradle/gh-pages/1.0/index.html').exists()
114 | file('/.gradle/gh-pages/index.html').exists()
115 | file('/.gradle/gh-pages/index.html').text.contains('URL=\'1.1\'')
116 |
117 | then: "versions file correct"
118 | result.output.contains("Versions file generated with 2 versions:")
119 | file('/.gradle/gh-pages/versions.json').exists()
120 | with(new JsonSlurper().parse(file('/.gradle/gh-pages/versions.json')) as List) {
121 | it.size() == 2
122 | it[0]['title'] == '1.1'
123 | it[1]['title'] == '1.0'
124 | }
125 |
126 |
127 |
128 | when: "run from cache"
129 | println '\n\n------------------- FROM CACHE ----------------------------------------'
130 | result = run('--configuration-cache', '--configuration-cache-problems=warn', 'mkdocsPublish')
131 |
132 | then: "cache used"
133 | result.output.contains('Reusing configuration cache.')
134 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
135 | file('/.gradle/gh-pages/1.1/index.html').exists()
136 | file('/.gradle/gh-pages/1.0/index.html').exists()
137 | file('/.gradle/gh-pages/index.html').exists()
138 | file('/.gradle/gh-pages/index.html').text.contains('URL=\'1.1\'')
139 | }
140 | }
141 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/CustomThemeKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 |
6 | /**
7 | * @author Vyacheslav Rusakov
8 | * @since 17.03.2021
9 | */
10 | class CustomThemeKitTest extends AbstractKitTest {
11 |
12 | def "Check theme change"() {
13 | setup:
14 | build """
15 | plugins {
16 | id 'ru.vyarus.mkdocs'
17 | }
18 |
19 | version = '1.0'
20 |
21 | python.pip 'mkdocs-ivory:0.4.6'
22 |
23 | mkdocs {
24 | sourcesDir 'doc'
25 | }
26 | """
27 |
28 | file('doc').mkdir()
29 | file('doc/mkdocs.yml') << """
30 | site_name: test
31 |
32 | theme:
33 | name: 'ivory'
34 |
35 | nav:
36 | - Home: index.md
37 | """
38 | file('doc/docs').mkdir()
39 | file('doc/docs/index.md') << """
40 | # Index page
41 | """
42 |
43 | when: "run build"
44 | BuildResult result = run('mkdocsBuild')
45 |
46 | then: "build success"
47 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
48 | file('build/mkdocs/1.0/index.html').exists()
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/DocsInModuleAndRootKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.ajoberstar.grgit.Grgit
4 | import org.gradle.testkit.runner.BuildResult
5 | import org.gradle.testkit.runner.TaskOutcome
6 | import spock.lang.TempDir
7 |
8 | /**
9 | * @author Vyacheslav Rusakov
10 | * @since 04.08.2022
11 | */
12 | class DocsInModuleAndRootKitTest extends AbstractKitTest {
13 |
14 | @TempDir File repoDir
15 |
16 | Grgit repo
17 |
18 | @Override
19 | def setup() {
20 | // local repo used for push
21 | println 'init fake gh-pages repo'
22 | repo = Grgit.init(dir: repoDir, bare: true)
23 | assert repo.branch.list().size() == 0
24 | // connect with project folder
25 | println 'associate project with fake repo'
26 | Grgit prjRepo = Grgit.init(dir: testProjectDir)
27 | prjRepo.remote.add(name: 'origin', url: repoDir.canonicalPath, pushUrl: repoDir.canonicalPath)
28 | // init remote repo
29 | file('readme.txt') << 'sample'
30 | prjRepo.add(patterns: ['*'])
31 | prjRepo.commit(message: 'initial commit')
32 | prjRepo.push()
33 | prjRepo.close()
34 |
35 | assert repo.log().size() == 1
36 | assert repo.branch.list().size() == 1
37 | }
38 |
39 | void cleanup() {
40 | repo.close()
41 | }
42 |
43 | def "Check docs in root and submodule"() {
44 |
45 | // both published into the same git, but with different naming scheme
46 |
47 | setup:
48 | file('settings.gradle') << ' include "doc"'
49 | file('doc').mkdir()
50 | build """
51 | plugins {
52 | id 'ru.vyarus.mkdocs'
53 | }
54 |
55 | version = '1.0-SNAPSHOT'
56 |
57 | mkdocs {
58 | sourcesDir = 'docs'
59 | }
60 |
61 | project(':doc') {
62 | apply plugin: 'ru.vyarus.mkdocs'
63 |
64 | mkdocs {
65 | sourcesDir = 'src'
66 |
67 | publish {
68 | docPath = 'sub-\$version'
69 | rootRedirect = false
70 | }
71 | }
72 | }
73 |
74 | """
75 |
76 | // root docs
77 | file('docs').mkdir()
78 | file('docs/mkdocs.yml') << """
79 | site_name: root
80 |
81 | nav:
82 | - Home: index.md
83 | """
84 | file('docs/docs').mkdir()
85 | file('docs/docs/index.md') << """
86 | root index page
87 | """
88 |
89 | // module docs
90 | file('doc').mkdir()
91 | file('doc/src').mkdir()
92 | file('doc/src/mkdocs.yml') << """
93 | site_name: sub
94 |
95 | nav:
96 | - Home: index.md
97 | """
98 |
99 | file('doc/src/docs').mkdir()
100 | file('doc/src/docs/index.md') << """
101 | submodule index page
102 | """
103 |
104 | when: "build site"
105 | BuildResult result = run('mkdocsPublish')
106 |
107 | then: "built"
108 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
109 | result.task(':doc:mkdocsPublish').outcome == TaskOutcome.SUCCESS
110 | file('build/mkdocs/1.0-SNAPSHOT/index.html').text.contains('root index page')
111 | file('doc/build/mkdocs/sub-1.0-SNAPSHOT/index.html').text.contains('submodule index page')
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/DocsInModuleKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 |
6 | /**
7 | * @author Vyacheslav Rusakov
8 | * @since 14.10.2018
9 | */
10 | class DocsInModuleKitTest extends AbstractKitTest {
11 |
12 | def "Check docs submodule workflow"() {
13 | setup:
14 | file('settings.gradle') << ' include "doc"'
15 | file('doc').mkdir()
16 | build """
17 | plugins {
18 | id 'ru.vyarus.mkdocs' apply false
19 | }
20 |
21 | version = '1.0-SNAPSHOT'
22 |
23 | project(':doc') {
24 | apply plugin: 'ru.vyarus.mkdocs'
25 |
26 | mkdocs {
27 | sourcesDir = 'src'
28 | }
29 | }
30 |
31 | """
32 |
33 | when: "run init"
34 | BuildResult result = run(':doc:mkdocsInit')
35 |
36 | then: "docs created"
37 | result.task(':doc:mkdocsInit').outcome == TaskOutcome.SUCCESS
38 | file('doc/src/mkdocs.yml').exists()
39 |
40 | when: "build site"
41 | result = run(':doc:mkdocsBuild')
42 |
43 | then: "built"
44 | result.task(':doc:mkdocsBuild').outcome == TaskOutcome.SUCCESS
45 | file('doc/build/mkdocs/1.0-SNAPSHOT/index.html').exists()
46 |
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/LegacyKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 | import spock.lang.IgnoreIf
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 13.03.2020
10 | */
11 | @IgnoreIf({jvm.java17Compatible}) // only gradle 7.3 supports java 17
12 | class LegacyKitTest extends AbstractKitTest {
13 |
14 | String GRADLE_VERSION = '7.0'
15 |
16 | def "Check workflow"() {
17 | setup:
18 | build """
19 | plugins {
20 | id 'ru.vyarus.mkdocs'
21 | }
22 |
23 | version = '1.0-SNAPSHOT'
24 | python.scope = USER
25 | """
26 |
27 | when: "run init"
28 | BuildResult result = runVer(GRADLE_VERSION, 'mkdocsInit')
29 |
30 | then: "docs created"
31 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
32 | file('src/doc/mkdocs.yml').exists()
33 |
34 | when: "build site"
35 | result = runVer(GRADLE_VERSION, 'mkdocsBuild')
36 |
37 | then: "built"
38 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
39 | file('build/mkdocs/1.0-SNAPSHOT/index.html').exists()
40 |
41 | }
42 |
43 | def "Check custom task"() {
44 |
45 | setup:
46 | build """
47 | plugins {
48 | id 'ru.vyarus.mkdocs'
49 | }
50 |
51 | python.scope = USER
52 |
53 | task mkHelp(type: MkdocsTask) {
54 | command = '--help'
55 | }
56 | """
57 |
58 | when: "run help"
59 | BuildResult result = runVer(GRADLE_VERSION, 'mkHelp')
60 |
61 | then: "executed"
62 | result.task(':mkHelp').outcome == TaskOutcome.SUCCESS
63 | result.output.contains('-V, --version Show the version and exit.')
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/MkdocsBuildKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 |
6 | /**
7 | * @author Vyacheslav Rusakov
8 | * @since 28.10.2022
9 | */
10 | class MkdocsBuildKitTest extends AbstractKitTest {
11 |
12 | def "Check workflow"() {
13 | setup:
14 | build """
15 | plugins {
16 | id 'ru.vyarus.mkdocs-build'
17 | }
18 |
19 | version = '1.0-SNAPSHOT'
20 | python.scope = USER
21 | """
22 |
23 | when: "run init"
24 | BuildResult result = run('mkdocsInit')
25 |
26 | then: "docs created"
27 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
28 | file('src/doc/mkdocs.yml').exists()
29 |
30 | when: "build site"
31 | result = run('mkdocsBuild')
32 |
33 | then: "built"
34 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
35 | file('build/mkdocs/1.0-SNAPSHOT/index.html').exists()
36 |
37 | }
38 |
39 | def "Check custom task"() {
40 |
41 | setup:
42 | build """
43 | plugins {
44 | id 'ru.vyarus.mkdocs-build'
45 | }
46 |
47 | python.scope = USER
48 |
49 | task mkHelp(type: MkdocsTask) {
50 | command = '--help'
51 | }
52 | """
53 |
54 | when: "run help"
55 | BuildResult result = run('mkHelp')
56 |
57 | then: "executed"
58 | result.task(':mkHelp').outcome == TaskOutcome.SUCCESS
59 | result.output.contains('-V, --version Show the version and exit.')
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/MkdocsBuildPluginTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.api.Project
4 | import org.gradle.testfixtures.ProjectBuilder
5 | import ru.vyarus.gradle.plugin.python.PythonExtension
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 28.10.2022
10 | */
11 | class MkdocsBuildPluginTest extends AbstractTest {
12 |
13 | def "Check extension registration"() {
14 |
15 | when: "plugin applied"
16 | Project project = ProjectBuilder.builder().build()
17 | project.plugins.apply "ru.vyarus.mkdocs-build"
18 |
19 | then: "extension registered"
20 | project.extensions.findByType(MkdocsExtension)
21 |
22 | then: "default modules registered"
23 | project.extensions.findByType(PythonExtension).modules == MkdocsExtension.DEFAULT_MODULES as List
24 |
25 | then: "mkdocs tasks registered"
26 | def task = { project.tasks.findByName(it) }
27 | task('mkdocsBuild')
28 | task('mkdocsServe')
29 | task('mkdocsInit')
30 | !task('mkdocsPublish')
31 |
32 | then: "publish extension not applied"
33 | !project.extensions.findByType(GitPublishExtension)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/MkdocsPluginKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 |
6 | /**
7 | * @author Vyacheslav Rusakov
8 | * @since 29.10.2017
9 | */
10 | class MkdocsPluginKitTest extends AbstractKitTest {
11 |
12 | def "Check workflow"() {
13 | setup:
14 | build """
15 | plugins {
16 | id 'ru.vyarus.mkdocs'
17 | }
18 |
19 | version = '1.0-SNAPSHOT'
20 | python.scope = USER
21 | """
22 |
23 | when: "run init"
24 | BuildResult result = run('mkdocsInit')
25 |
26 | then: "docs created"
27 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
28 | file('src/doc/mkdocs.yml').exists()
29 |
30 | when: "build site"
31 | result = run('mkdocsBuild')
32 |
33 | then: "built"
34 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
35 | file('build/mkdocs/1.0-SNAPSHOT/index.html').exists()
36 |
37 | }
38 |
39 | def "Check custom task"() {
40 |
41 | setup:
42 | build """
43 | plugins {
44 | id 'ru.vyarus.mkdocs'
45 | }
46 |
47 | python.scope = USER
48 |
49 | task mkHelp(type: MkdocsTask) {
50 | command = '--help'
51 | }
52 | """
53 |
54 | when: "run help"
55 | BuildResult result = run('mkHelp')
56 |
57 | then: "executed"
58 | result.task(':mkHelp').outcome == TaskOutcome.SUCCESS
59 | result.output.contains('-V, --version Show the version and exit.')
60 | }
61 | }
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/MkdocsPluginTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.api.Project
4 | import org.gradle.api.tasks.TaskProvider
5 | import org.gradle.testfixtures.ProjectBuilder
6 | import ru.vyarus.gradle.plugin.mkdocs.task.publish.GitPublishPush
7 | import ru.vyarus.gradle.plugin.python.PythonExtension
8 |
9 | /**
10 | * @author Vyacheslav Rusakov
11 | * @since 29.10.2017
12 | */
13 | class MkdocsPluginTest extends AbstractTest {
14 |
15 | def "Check extension registration"() {
16 |
17 | when: "plugin applied"
18 | Project project = ProjectBuilder.builder().build()
19 | project.plugins.apply "ru.vyarus.mkdocs"
20 |
21 | then: "extension registered"
22 | project.extensions.findByType(MkdocsExtension)
23 |
24 | then: "default modules registered"
25 | project.extensions.findByType(PythonExtension).modules == MkdocsExtension.DEFAULT_MODULES as List
26 |
27 | then: "mkdocs tasks registered"
28 | def task = { project.tasks.findByName(it) }
29 | task('mkdocsBuild')
30 | task('mkdocsServe')
31 | task('mkdocsInit')
32 | task('mkdocsPublish')
33 |
34 | then: "publish plugin applied"
35 | project.extensions.findByType(GitPublishExtension)
36 |
37 | then: "task graph valid"
38 | (task('mkdocsPublish').dependsOn[0] as TaskProvider).get() instanceof GitPublishPush
39 | task('gitPublishReset').dependsOn.contains('mkdocsBuild')
40 | }
41 |
42 | def "Check default resolution"() {
43 |
44 | when: "plugin applied"
45 | Project project = ProjectBuilder.builder().build()
46 | project.version = '1.0'
47 | project.plugins.apply "ru.vyarus.mkdocs"
48 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
49 |
50 | then: 'resolution correct'
51 | ext.resolveDocPath() == '1.0'
52 | ext.resolveComment() == 'Publish 1.0 documentation'
53 |
54 | }
55 |
56 | def "Check extra slashes resolution"() {
57 |
58 | when: "plugin applied"
59 | Project project = ProjectBuilder.builder().build()
60 | project.version = '1.0'
61 | project.plugins.apply "ru.vyarus.mkdocs"
62 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
63 | ext.publish.docPath = '/1.0/'
64 |
65 | then: 'resolution correct'
66 | ext.resolveDocPath() == '1.0'
67 | ext.resolveComment() == 'Publish 1.0 documentation'
68 |
69 | }
70 |
71 | def "Check complex path resolution"() {
72 |
73 | when: "plugin applied"
74 | Project project = ProjectBuilder.builder().build()
75 | project.version = '1.0'
76 | project.plugins.apply "ru.vyarus.mkdocs"
77 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
78 | ext.publish.docPath = '/en/$version/'
79 |
80 | then: 'resolution correct'
81 | ext.resolveDocPath() == 'en/1.0'
82 | ext.resolveComment() == 'Publish en/1.0 documentation'
83 |
84 | }
85 |
86 | def "Check no multi-version"() {
87 |
88 | when: "plugin applied"
89 | Project project = ProjectBuilder.builder().build()
90 | project.version = '1.0'
91 | project.plugins.apply "ru.vyarus.mkdocs"
92 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
93 | ext.publish.docPath = null
94 |
95 | then: 'resolution correct'
96 | ext.resolveDocPath() == MkdocsExtension.SINGLE_VERSION_PATH
97 | ext.resolveComment() == 'Publish documentation'
98 |
99 | }
100 |
101 | def "Check no multi-version 2"() {
102 |
103 | when: "plugin applied"
104 | Project project = ProjectBuilder.builder().build()
105 | project.version = '1.0'
106 | project.plugins.apply "ru.vyarus.mkdocs"
107 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
108 | ext.publish.docPath = ''
109 |
110 | then: 'resolution correct'
111 | ext.resolveDocPath() == MkdocsExtension.SINGLE_VERSION_PATH
112 | ext.resolveComment() == 'Publish documentation'
113 |
114 | }
115 |
116 | def "Check extra variables"() {
117 |
118 | when: "plugin applied"
119 | Project project = project {
120 | apply plugin: 'ru.vyarus.mkdocs'
121 |
122 | version = 1.0
123 | mkdocs {
124 | extras = [
125 | 'foo': project.version,
126 | 'bar': "${-> project.version }",
127 | ]
128 | }
129 |
130 | version = 1.1
131 | }
132 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
133 |
134 | then: 'resolution correct'
135 | ext.extras.foo == 1.0
136 | ext.extras.bar == 1.1
137 |
138 | }
139 |
140 | def "Check version validation"() {
141 |
142 | when: "plugin applied"
143 | Project project = ProjectBuilder.builder().build()
144 | project.plugins.apply "ru.vyarus.mkdocs"
145 | MkdocsExtension ext = project.extensions.findByType(MkdocsExtension)
146 |
147 | then: 'failed'
148 | ext.resolveDocPath() == 'unspecified'
149 |
150 | }
151 | }
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/UpstreamKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 |
6 | /**
7 | * @author Vyacheslav Rusakov
8 | * @since 13.03.2020
9 | */
10 | class UpstreamKitTest extends AbstractKitTest {
11 |
12 | String GRADLE_VERSION = '8.7'
13 |
14 | def "Check workflow"() {
15 | setup:
16 | build """
17 | plugins {
18 | id 'ru.vyarus.mkdocs'
19 | }
20 |
21 | version = '1.0-SNAPSHOT'
22 | python.scope = USER
23 | """
24 |
25 | when: "run init"
26 | BuildResult result = runVer(GRADLE_VERSION, 'mkdocsInit', '--warning-mode', 'all')
27 |
28 | then: "docs created"
29 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
30 | file('src/doc/mkdocs.yml').exists()
31 |
32 | when: "build site"
33 | result = runVer(GRADLE_VERSION, 'mkdocsBuild', '--warning-mode', 'all')
34 |
35 | then: "built"
36 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
37 | file('build/mkdocs/1.0-SNAPSHOT/index.html').exists()
38 |
39 | }
40 |
41 | def "Check custom task"() {
42 |
43 | setup:
44 | build """
45 | plugins {
46 | id 'ru.vyarus.mkdocs'
47 | }
48 |
49 | python.scope = USER
50 |
51 | task mkHelp(type: MkdocsTask) {
52 | command = '--help'
53 | }
54 | """
55 |
56 | when: "run help"
57 | BuildResult result = runVer(GRADLE_VERSION, 'mkHelp', '--warning-mode', 'all')
58 |
59 | then: "executed"
60 | result.task(':mkHelp').outcome == TaskOutcome.SUCCESS
61 | result.output.contains('-V, --version Show the version and exit.')
62 | }
63 |
64 | def "Check extra props"() {
65 |
66 | setup:
67 | build """
68 | plugins {
69 | id 'ru.vyarus.mkdocs'
70 | }
71 |
72 | python.scope = USER
73 |
74 | mkdocs {
75 | sourcesDir = 'doc'
76 | extras = [
77 | 'version': "\${-> project.version}",
78 | ]
79 | }
80 |
81 | task mkHelp(type: MkdocsTask) {
82 | command = '--help'
83 | }
84 | """
85 |
86 | file('doc').mkdir()
87 | file('doc/mkdocs.yml') << """
88 | site_name: test
89 |
90 | plugins:
91 | - search
92 | - markdownextradata
93 |
94 | nav:
95 | - Home: index.md
96 | """
97 |
98 | when: "run help"
99 | BuildResult result = runVer(GRADLE_VERSION, 'mkHelp', '--warning-mode', 'all')
100 |
101 | then: "executed"
102 | result.task(':mkHelp').outcome == TaskOutcome.SUCCESS
103 | result.output.contains('-V, --version Show the version and exit.')
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/UpstreamPublishKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.ajoberstar.grgit.Grgit
4 | import org.gradle.testkit.runner.BuildResult
5 | import org.gradle.testkit.runner.TaskOutcome
6 | import spock.lang.TempDir
7 |
8 | /**
9 | * @author Vyacheslav Rusakov
10 | * @since 02.03.2021
11 | */
12 | class UpstreamPublishKitTest extends AbstractKitTest {
13 |
14 | String GRADLE_VERSION = '8.7'
15 |
16 | @TempDir File repoDir
17 |
18 | Grgit repo
19 |
20 | @Override
21 | def setup() {
22 | // local repo used for push
23 | println 'init fake gh-pages repo'
24 | repo = Grgit.init(dir: repoDir, bare: true)
25 | assert repo.branch.list().size() == 0
26 | // connect with project folder
27 | println 'associate project with fake repo'
28 | Grgit prjRepo = Grgit.init(dir: testProjectDir)
29 | prjRepo.remote.add(name: 'origin', url: repoDir.canonicalPath, pushUrl: repoDir.canonicalPath)
30 | // init remote repo
31 | file('readme.txt') << 'sample'
32 | prjRepo.add(patterns: ['*'])
33 | prjRepo.commit(message: 'initial commit')
34 | prjRepo.push()
35 | prjRepo.close()
36 |
37 | assert repo.log().size() == 1
38 | assert repo.branch.list().size() == 1
39 | }
40 |
41 | void cleanup() {
42 | repo.close()
43 | }
44 |
45 | def "Check default publish"() {
46 |
47 | setup:
48 | build """
49 | plugins {
50 | id 'ru.vyarus.mkdocs'
51 | }
52 |
53 | version = '1.0'
54 |
55 | python.scope = USER
56 | """
57 |
58 | when: "run init"
59 | BuildResult result = runVer(GRADLE_VERSION, 'mkdocsInit', '--warning-mode', 'all')
60 |
61 | then: "docs created"
62 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
63 | file('src/doc/mkdocs.yml').exists()
64 |
65 | when: "publish"
66 | // debug()
67 | // println 'wait for debugger'
68 | result = runVer(GRADLE_VERSION, 'mkdocsPublish', '--warning-mode', 'all')
69 |
70 | then: "published"
71 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
72 | repo.branch.list().size() == 2
73 |
74 | then: "content available"
75 | file('/.gradle/gh-pages/1.0/index.html').exists()
76 | file('/.gradle/gh-pages/index.html').exists()
77 |
78 |
79 | when: "publish another version"
80 | buildFile.delete()
81 | build """
82 | plugins {
83 | id 'ru.vyarus.mkdocs'
84 | }
85 |
86 | version = '1.1'
87 |
88 | python.scope = USER
89 | """
90 | result = runVer(GRADLE_VERSION, 'mkdocsPublish', '--warning-mode', 'all')
91 |
92 | then: "version published"
93 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
94 | file('/.gradle/gh-pages/1.1/index.html').exists()
95 | file('/.gradle/gh-pages/1.0/index.html').exists()
96 | file('/.gradle/gh-pages/index.html').exists()
97 | file('/.gradle/gh-pages/index.html').text.contains('URL=\'1.1\'')
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/VersionsUpdateKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 |
6 | /**
7 | * @author Vyacheslav Rusakov
8 | * @since 31.10.2022
9 | */
10 | class VersionsUpdateKitTest extends AbstractKitTest {
11 |
12 | def "Check versions file creation with build"() {
13 | setup:
14 | build """
15 | plugins {
16 | id 'ru.vyarus.mkdocs'
17 | }
18 |
19 | version = '1.0'
20 |
21 | mkdocs.publish.existingVersionsFile = 'prev-versions.json'
22 |
23 | python.scope = USER
24 | """
25 |
26 | when: "run init"
27 | BuildResult result = run('mkdocsInit')
28 |
29 | then: "docs created"
30 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
31 |
32 | when: "build site"
33 | result = run('mkdocsBuild')
34 | File vers = file('build/mkdocs/versions.json')
35 | println vers.text
36 |
37 | then: "built"
38 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
39 | vers.exists()
40 | result.output.contains('WARNING: configured versions file \'prev-versions.json\' does not exist - creating new file instead')
41 | result.output.contains('New version added: 1.0')
42 | result.output.contains('Versions written to file: 1.0')
43 |
44 | }
45 |
46 | def "Check not existing versions file url"() {
47 | setup:
48 | build """
49 | plugins {
50 | id 'ru.vyarus.mkdocs'
51 | }
52 |
53 | version = '1.0'
54 |
55 | mkdocs.publish.existingVersionsFile = 'https://xvik.github.io/gradle-use-python-plugin/versionssss.json'
56 |
57 | python.scope = USER
58 | """
59 |
60 | when: "run init"
61 | BuildResult result = run('mkdocsInit')
62 |
63 | then: "docs created"
64 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
65 |
66 | when: "build site"
67 | result = run('mkdocsBuild')
68 | File vers = file('build/mkdocs/versions.json')
69 | println vers.text
70 |
71 | then: "built"
72 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
73 | vers.exists()
74 | result.output.contains('WARNING: configured versions file \'https://xvik.github.io/gradle-use-python-plugin/versionssss.json\' does not exist - creating new file instead')
75 | result.output.contains('New version added: 1.0')
76 | result.output.contains('Versions written to file: 1.0')
77 | }
78 |
79 | def "Check versions file update"() {
80 | setup:
81 | build """
82 | plugins {
83 | id 'ru.vyarus.mkdocs'
84 | }
85 |
86 | version = '3.0'
87 |
88 | mkdocs.publish.existingVersionsFile = 'prev-versions.json'
89 |
90 | python.scope = USER
91 | """
92 | file('prev-versions.json') << '[{"version":"2.0.0","title":"2.0.0","aliases":["latest"]},{"version":"1.0.0","title":"1.0.0","aliases":[]}]'
93 |
94 | when: "run init"
95 | BuildResult result = run('mkdocsInit')
96 |
97 | then: "docs created"
98 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
99 |
100 | when: "build site"
101 | result = run('mkdocsBuild')
102 | File vers = file('build/mkdocs/versions.json')
103 | println vers.text
104 |
105 | then: "built"
106 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
107 | vers.exists()
108 | result.output.contains('Existing versions file \'prev-versions.json\' loaded with 2 versions')
109 | result.output.contains('New version added: 3.0')
110 | result.output.contains('Versions written to file: 3.0, 2.0.0, 1.0.0')
111 |
112 | }
113 |
114 | def "Check aliases update"() {
115 | setup:
116 | build """
117 | plugins {
118 | id 'ru.vyarus.mkdocs'
119 | }
120 |
121 | version = '3.0'
122 |
123 | mkdocs.publish {
124 | versionAliases = ['latest']
125 | existingVersionsFile = 'prev-versions.json'
126 | }
127 |
128 | python.scope = USER
129 | """
130 | file('prev-versions.json') << '[{"version":"2.0.0","title":"2.0.0","aliases":["latest"]},{"version":"1.0.0","title":"1.0.0","aliases":[]}]'
131 |
132 | when: "run init"
133 | BuildResult result = run('mkdocsInit')
134 |
135 | then: "docs created"
136 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
137 |
138 | when: "build site"
139 | result = run('mkdocsBuild')
140 | File vers = file('build/mkdocs/versions.json')
141 | println vers.text
142 |
143 | then: "built"
144 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
145 | vers.text == '[{"version":"3.0","title":"3.0","aliases":["latest"]},{"version":"2.0.0","title":"2.0.0","aliases":[]},{"version":"1.0.0","title":"1.0.0","aliases":[]}]'
146 |
147 | }
148 |
149 | def "Check version already declared"() {
150 | setup:
151 | build """
152 | plugins {
153 | id 'ru.vyarus.mkdocs'
154 | }
155 |
156 | version = '3.0'
157 |
158 | mkdocs.publish {
159 | versionAliases = ['latest']
160 | existingVersionsFile = 'prev-versions.json'
161 | }
162 |
163 | python.scope = USER
164 | """
165 | file('prev-versions.json') << '[{"version":"3.0","title":"3.0","aliases":["latest"]},{"version":"2.0.0","title":"2.0.0","aliases":[]},{"version":"1.0.0","title":"1.0.0","aliases":[]}]'
166 |
167 | when: "run init"
168 | BuildResult result = run('mkdocsInit')
169 |
170 | then: "docs created"
171 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
172 |
173 | when: "build site"
174 | result = run('mkdocsBuild')
175 | File vers = file('build/mkdocs/versions.json')
176 | println vers.text
177 |
178 | then: "built"
179 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
180 | vers.text == '[{"version":"3.0","title":"3.0","aliases":["latest"]},{"version":"2.0.0","title":"2.0.0","aliases":[]},{"version":"1.0.0","title":"1.0.0","aliases":[]}]'
181 |
182 | }
183 |
184 | def "Check versions file from url update"() {
185 | setup:
186 | build """
187 | plugins {
188 | id 'ru.vyarus.mkdocs'
189 | }
190 |
191 | version = '1.0'
192 |
193 | mkdocs.publish.existingVersionsFile = 'https://xvik.github.io/gradle-use-python-plugin/versions.json'
194 |
195 | python.scope = USER
196 | """
197 |
198 | when: "run init"
199 | BuildResult result = run('mkdocsInit')
200 |
201 | then: "docs created"
202 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
203 |
204 | when: "build site"
205 | result = run('mkdocsBuild')
206 | File vers = file('build/mkdocs/versions.json')
207 | println vers.text
208 |
209 | then: "built"
210 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
211 | vers.exists()
212 | result.output.contains('Existing versions file \'https://xvik.github.io/gradle-use-python-plugin/versions.json\' loaded with')
213 | result.output.contains('New version added: 1.0')
214 |
215 | }
216 | }
217 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/docker/DockerKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.docker
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 | import ru.vyarus.gradle.plugin.mkdocs.AbstractKitTest
6 | import spock.lang.IgnoreIf
7 |
8 | /**
9 | * @author Vyacheslav Rusakov
10 | * @since 13.10.2022
11 | */
12 | // testcontainers doesn't work on windows server https://github.com/testcontainers/testcontainers-java/issues/2960
13 | @IgnoreIf({ System.getProperty("os.name").toLowerCase().contains("windows") })
14 | class DockerKitTest extends AbstractKitTest {
15 |
16 | def "Check workflow"() {
17 | setup:
18 | build """
19 | plugins {
20 | id 'ru.vyarus.mkdocs'
21 | }
22 |
23 | version = '1.0-SNAPSHOT'
24 | python.docker.use = true
25 | """
26 |
27 | when: "run init"
28 | BuildResult result = run('mkdocsInit')
29 |
30 | then: "docs created"
31 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
32 | file('src/doc/mkdocs.yml').exists()
33 |
34 | when: "build site"
35 | result = run('mkdocsBuild')
36 |
37 | then: "built"
38 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
39 | file('build/mkdocs/1.0-SNAPSHOT/index.html').exists()
40 |
41 | }
42 |
43 | def "Check build"() {
44 | setup:
45 | build """
46 | plugins {
47 | id 'ru.vyarus.mkdocs'
48 | }
49 |
50 | version = '1.0'
51 |
52 | python.docker.use = true
53 | """
54 |
55 | when: "run init"
56 | BuildResult result = run('mkdocsInit')
57 |
58 | then: "docs created"
59 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
60 |
61 | when: "build site"
62 | File conf = file('src/doc/mkdocs.yml')
63 | conf.text = conf.text.replaceAll(/(?m)^site_url:.*/, "site_url: http://localhost")
64 | result = run('mkdocsBuild')
65 |
66 | then: "built"
67 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
68 | result.output =~ /python -m mkdocs build -c -d [^(-)]+ -s/
69 |
70 | file('build/mkdocs/1.0/index.html').exists()
71 | // site_url wasn't modified
72 | file('build/mkdocs/1.0/sitemap.xml').text.contains('http://localhost/1.0/guide/installation/')
73 | file('build/mkdocs/index.html').exists()
74 | file('build/mkdocs/index.html').text.contains('URL=\'1.0\'')
75 |
76 | when: "up to date check"
77 | result = run('mkdocsBuild')
78 |
79 | then: "ok"
80 | result.task(':mkdocsBuild').outcome == TaskOutcome.UP_TO_DATE
81 |
82 | }
83 |
84 | def "Check serve"() {
85 | setup:
86 | build """
87 | plugins {
88 | id 'ru.vyarus.mkdocs'
89 | }
90 |
91 | python.docker.use = true
92 | """
93 | file('src/doc/').mkdirs()
94 |
95 | when: "serve site"
96 | BuildResult result = runFailed('mkdocsServe')
97 |
98 | then: "command correct"
99 | result.task(':mkdocsServe').outcome == TaskOutcome.FAILED
100 | result.output =~ /python -m mkdocs serve --dev-addr 0.0.0.0:3000/
101 | }
102 |
103 | }
104 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/task/BuildTaskKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 | import ru.vyarus.gradle.plugin.mkdocs.AbstractKitTest
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 29.11.2017
10 | */
11 | class BuildTaskKitTest extends AbstractKitTest {
12 |
13 | def "Check build"() {
14 | setup:
15 | build """
16 | plugins {
17 | id 'ru.vyarus.mkdocs'
18 | }
19 |
20 | version = '1.0'
21 |
22 | python.scope = USER
23 | """
24 |
25 | when: "run init"
26 | BuildResult result = run('mkdocsInit')
27 |
28 | then: "docs created"
29 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
30 |
31 | when: "build site"
32 | File conf = file('src/doc/mkdocs.yml')
33 | conf.text = conf.text.replaceAll(/(?m)^site_url:.*/, "site_url: http://localhost")
34 | result = run('mkdocsBuild')
35 |
36 | then: "built"
37 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
38 | result.output =~ /\[python] python(3)? -m mkdocs build -c -d ${isWin ? '"[^"]+"' : '[^(-)]+'} -s/
39 |
40 | file('build/mkdocs/1.0/index.html').exists()
41 | // site_url wasn't modified
42 | file('build/mkdocs/1.0/sitemap.xml').text.contains('http://localhost/1.0/guide/installation/')
43 | file('build/mkdocs/index.html').exists()
44 | file('build/mkdocs/index.html').text.contains('URL=\'1.0\'')
45 |
46 | when: "up to date check"
47 | result = run('mkdocsBuild')
48 |
49 | then: "ok"
50 | result.task(':mkdocsBuild').outcome == TaskOutcome.UP_TO_DATE
51 |
52 | }
53 |
54 | def "Check non strict build"() {
55 | setup:
56 | build """
57 | plugins {
58 | id 'ru.vyarus.mkdocs'
59 | }
60 |
61 | version = '1.0'
62 |
63 | python.scope = USER
64 |
65 | mkdocs.strict = false
66 | """
67 |
68 | when: "run init"
69 | BuildResult result = run('mkdocsInit')
70 |
71 | then: "docs created"
72 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
73 |
74 | when: "build site"
75 | File conf = file('src/doc/mkdocs.yml')
76 | conf.text = conf.text.replaceAll(/(?m)^site_url:.*/, "site_url: http://localhost")
77 | result = run('mkdocsBuild')
78 |
79 | then: "built"
80 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
81 | result.output =~ /\[python] python(3)? -m mkdocs build -c -d ${isWin ? '"[^"]+"' : '[^(-)]+'}/
82 |
83 | file('build/mkdocs/1.0/index.html').exists()
84 | // site_url wasn't modified
85 | file('build/mkdocs/1.0/sitemap.xml').text.contains('http://localhost/1.0/guide/installation/')
86 | file('build/mkdocs/index.html').exists()
87 | file('build/mkdocs/index.html').text.contains('URL=\'1.0\'')
88 |
89 | when: "up to date check"
90 | result = run('mkdocsBuild')
91 |
92 | then: "ok"
93 | result.task(':mkdocsBuild').outcome == TaskOutcome.UP_TO_DATE
94 |
95 | }
96 |
97 |
98 | def "Check build path with space"() {
99 | setup:
100 | build """
101 | plugins {
102 | id 'ru.vyarus.mkdocs'
103 | }
104 |
105 | version = 'v 1.0'
106 |
107 | python.scope = USER
108 | """
109 |
110 | when: "run init"
111 | BuildResult result = run('mkdocsInit')
112 |
113 | then: "docs created"
114 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
115 | file('src/doc/mkdocs.yml').exists()
116 |
117 | when: "build site"
118 | result = run('mkdocsBuild')
119 | println(file('build/mkdocs/').list())
120 |
121 | then: "built"
122 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
123 | result.output =~ /\[python] python(3)? -m mkdocs build -c -d ${isWin ? '"[^"]+"' : '[^(-)]+'} -s/
124 | file('build/mkdocs/v 1.0/index.html').exists()
125 | }
126 |
127 |
128 | def "Check build not default doc"() {
129 | setup:
130 | build """
131 | plugins {
132 | id 'ru.vyarus.mkdocs'
133 | }
134 |
135 | version = '1.0'
136 |
137 | python.scope = USER
138 |
139 | mkdocs.publish {
140 | // simulation case: updating docs for older version
141 | docPath = '0.9'
142 | rootRedirect = false
143 | }
144 | """
145 |
146 | when: "run init"
147 | BuildResult result = run('mkdocsInit')
148 |
149 | then: "docs created"
150 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
151 | file('src/doc/mkdocs.yml').exists()
152 |
153 | when: "build site"
154 | result = run('mkdocsBuild')
155 |
156 | then: "built"
157 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
158 | file('build/mkdocs/0.9/index.html').exists()
159 | !file('build/mkdocs/index.html').exists()
160 |
161 | }
162 |
163 | def "Check non strict build"() {
164 | setup:
165 | build """
166 | plugins {
167 | id 'ru.vyarus.mkdocs'
168 | }
169 |
170 | python.scope = USER
171 |
172 | mkdocs.strict = false
173 | """
174 | file('src/doc/').mkdirs()
175 |
176 | when: "build site"
177 | BuildResult result = runFailed('mkdocsBuild')
178 |
179 | then: "command correct"
180 | result.task(':mkdocsBuild').outcome == TaskOutcome.FAILED
181 | !(result.output =~ /\[python] python(3)? -m mkdocs build -c -d ${isWin ? '"[^"]+"' : '[^(-)]+'} -s/)
182 | }
183 |
184 | def "Check different source folder"() {
185 |
186 | setup:
187 | build """
188 | plugins {
189 | id 'ru.vyarus.mkdocs'
190 | }
191 |
192 | python.scope = USER
193 |
194 | mkdocs.sourcesDir = 'docs'
195 | """
196 | file('docs/').mkdirs()
197 |
198 | when: "build site"
199 | BuildResult result = runFailed('mkdocsBuild')
200 |
201 | then: "correct source path used"
202 | result.task(':mkdocsBuild').outcome == TaskOutcome.FAILED
203 | result.output.contains("Mkdocs config file not found: docs${isWin ? '\\' : '/'}mkdocs.yml")
204 | }
205 |
206 |
207 | def "Check stale index.html remove"() {
208 |
209 | setup:
210 | build """
211 | plugins {
212 | id 'ru.vyarus.mkdocs'
213 | }
214 |
215 | python.scope = USER
216 | """
217 | file('docs/').mkdirs()
218 |
219 | when: "run init"
220 | BuildResult result = run('mkdocsInit')
221 |
222 | then: "docs created"
223 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
224 | file('src/doc/mkdocs.yml').exists()
225 |
226 | when: "build site"
227 | result = run('mkdocsBuild')
228 |
229 | then: "redirect index generated"
230 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
231 | file('build/mkdocs/index.html').exists()
232 |
233 | when: "building without redirect"
234 | buildFile.delete()
235 | build """
236 | plugins {
237 | id 'ru.vyarus.mkdocs'
238 | }
239 |
240 | python.scope = USER
241 |
242 | mkdocs.publish.rootRedirect = false
243 | """
244 | file('src/doc/docs/index.md') << 'overwrite file'
245 | result = run('mkdocsBuild')
246 |
247 | then: "index.html removed"
248 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
249 | !file('build/mkdocs/index.html').exists()
250 | }
251 |
252 | def "Check up to date"() {
253 | setup:
254 | build """
255 | plugins {
256 | id 'ru.vyarus.mkdocs'
257 | }
258 |
259 | version = '1.0'
260 |
261 | python.scope = USER
262 | """
263 | file('src/doc/').mkdirs()
264 |
265 | when: "run init"
266 | BuildResult result = run('mkdocsInit')
267 |
268 | then: "docs created"
269 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
270 | file('src/doc/mkdocs.yml').exists()
271 |
272 | when: "build site"
273 | result = run('mkdocsBuild')
274 |
275 | then: "built"
276 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
277 |
278 | when: "once again build"
279 | result = run('mkdocsBuild')
280 |
281 | then: "built"
282 | result.task(':mkdocsBuild').outcome == TaskOutcome.UP_TO_DATE
283 |
284 | }
285 | }
286 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/task/InitTaskKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 | import ru.vyarus.gradle.plugin.mkdocs.AbstractKitTest
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 23.11.2017
10 | */
11 | class InitTaskKitTest extends AbstractKitTest {
12 |
13 | def "Check site init"() {
14 | setup:
15 | build """
16 | plugins {
17 | id 'ru.vyarus.mkdocs'
18 | }
19 | description = 'desc'
20 |
21 | python.scope = USER
22 | """
23 |
24 | when: "run task"
25 | BuildResult result = run('mkdocsInit')
26 |
27 | then: "task successful"
28 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
29 | def yml = file('src/doc/mkdocs.yml')
30 | yml.exists()
31 | !yml.text.contains('@')
32 |
33 | then: "all dirs generated"
34 | file('src/doc/docs/index.md').exists()
35 | file('src/doc/docs/about/history.md').exists()
36 | file('src/doc/docs/guide/installation.md').exists()
37 | }
38 |
39 | def "Check site init into different dir"() {
40 | setup:
41 | build """
42 | plugins {
43 | id 'ru.vyarus.mkdocs'
44 | }
45 |
46 | python.scope = USER
47 |
48 | mkdocs.sourcesDir = 'docs'
49 | """
50 | file('docs/').mkdirs()
51 |
52 | when: "run task"
53 | BuildResult result = run('mkdocsInit')
54 |
55 | then: "task successful"
56 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
57 | result.output.contains('Mkdocs site initialized: docs')
58 | file('docs/mkdocs.yml').exists()
59 |
60 | then: "all dirs generated"
61 | file('docs/docs/index.md').exists()
62 | file('docs/docs/about/history.md').exists()
63 | file('docs/docs/guide/installation.md').exists()
64 | }
65 |
66 | def "Check init into existing docs dir"() {
67 | setup:
68 | build """
69 | plugins {
70 | id 'ru.vyarus.mkdocs'
71 | }
72 |
73 | python.scope = USER
74 | """
75 |
76 | when: "run task"
77 | BuildResult result = run('mkdocsInit')
78 |
79 | then: "task successful"
80 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
81 | def yml = file('src/doc/mkdocs.yml')
82 | yml.exists()
83 |
84 | when: "call init into already inited dir"
85 | result = runFailed('mkdocsInit')
86 | then: "error"
87 | result.output.contains('Can\'t init new mkdocs site because target directory is not empty:')
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/task/PublishJavadocKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import org.ajoberstar.grgit.Grgit
4 | import org.gradle.testkit.runner.BuildResult
5 | import org.gradle.testkit.runner.TaskOutcome
6 | import ru.vyarus.gradle.plugin.mkdocs.AbstractKitTest
7 | import spock.lang.TempDir
8 |
9 | /**
10 | * @author Vyacheslav Rusakov
11 | * @since 01.12.2017
12 | */
13 | class PublishJavadocKitTest extends AbstractKitTest {
14 |
15 | @TempDir File repoDir
16 |
17 | Grgit repo
18 |
19 | @Override
20 | def setup() {
21 | // local repo used for push
22 | println 'init fake gh-pages repo'
23 | repo = Grgit.init(dir: repoDir, bare: true)
24 | assert repo.branch.list().size() == 0
25 | // connect with project folder
26 | println 'associate project with fake repo'
27 | Grgit prjRepo = Grgit.init(dir: testProjectDir)
28 | prjRepo.remote.add(name: 'origin', url: repoDir.canonicalPath, pushUrl: repoDir.canonicalPath)
29 | // init remote repo
30 | file('readme.txt') << 'sample'
31 | prjRepo.add(patterns: ['*'])
32 | prjRepo.commit(message: 'initial commit')
33 | prjRepo.push()
34 | prjRepo.close()
35 |
36 | assert repo.log().size() == 1
37 | assert repo.branch.list().size() == 1
38 | }
39 |
40 | void cleanup() {
41 | repo.close()
42 | }
43 |
44 | def "Check additional resources publication"() {
45 |
46 | setup:
47 | build """
48 | plugins {
49 | id 'java'
50 | id 'ru.vyarus.mkdocs'
51 | }
52 |
53 | version = '1.0'
54 |
55 | python.scope = USER
56 |
57 | gitPublish.contents {
58 | from(javadoc) {
59 | into "\${mkdocs.resolveDocPath()}/javadoc"
60 | }
61 | }
62 |
63 | // dependency will not be set automatically
64 | gitPublishReset.dependsOn javadoc
65 |
66 | """
67 | file('src/main/java/').mkdirs()
68 | file('src/main/java/Sample.java') << """
69 | /**
70 | * Sample class.
71 | */
72 | public class Sample {}
73 | """
74 |
75 | when: "run init"
76 | BuildResult result = run('mkdocsInit')
77 |
78 | then: "docs created"
79 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
80 | file('src/doc/mkdocs.yml').exists()
81 |
82 | when: "publish"
83 | // debug()
84 | // println 'wait for debugger'
85 | result = run('mkdocsPublish')
86 |
87 | then: "published with javadoc"
88 | result.task(':mkdocsPublish').outcome == TaskOutcome.SUCCESS
89 |
90 | then: "content available"
91 | file('/.gradle/gh-pages/1.0/index.html').exists()
92 | file('/.gradle/gh-pages/1.0/javadoc/index.html').exists()
93 | }
94 |
95 | }
96 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/task/ServeTaskKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 | import ru.vyarus.gradle.plugin.mkdocs.AbstractKitTest
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 29.11.2017
10 | */
11 | class ServeTaskKitTest extends AbstractKitTest {
12 |
13 | def "Check serve"() {
14 | setup:
15 | build """
16 | plugins {
17 | id 'ru.vyarus.mkdocs'
18 | }
19 |
20 | python.scope = USER
21 | mkdocs.devPort = 3001
22 | """
23 | file('src/doc/').mkdirs()
24 |
25 | when: "serve site"
26 | BuildResult result = runFailed('mkdocsServe')
27 |
28 | then: "command correct"
29 | result.task(':mkdocsServe').outcome == TaskOutcome.FAILED
30 | result.output =~ /\[python] python(3)? -m mkdocs serve -s --dev-addr 127.0.0.1:3001/
31 | }
32 |
33 | def "Check non strict serve"() {
34 | setup:
35 | build """
36 | plugins {
37 | id 'ru.vyarus.mkdocs'
38 | }
39 |
40 | python.scope = USER
41 |
42 | mkdocs.strict = false
43 | """
44 | file('src/doc/').mkdirs()
45 |
46 | when: "serve site"
47 | BuildResult result = runFailed('mkdocsServe')
48 |
49 | then: "command correct"
50 | result.task(':mkdocsServe').outcome == TaskOutcome.FAILED
51 | result.output =~ /\[python] python(3)? -m mkdocs serve --dev-addr 127.0.0.1:3000/
52 | }
53 |
54 | def "Check different source folder"() {
55 |
56 | setup:
57 | build """
58 | plugins {
59 | id 'ru.vyarus.mkdocs'
60 | }
61 |
62 | python.scope = USER
63 |
64 | mkdocs.sourcesDir = 'docs'
65 | """
66 | file('docs/').mkdirs()
67 |
68 | when: "serve site"
69 | BuildResult result = runFailed('mkdocsServe')
70 |
71 | then: "correct source path used"
72 | result.task(':mkdocsServe').outcome == TaskOutcome.FAILED
73 | result.output.contains("Config file 'mkdocs.yml' does not exist.")
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/task/UrlChangeKitTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.task
2 |
3 | import org.gradle.testkit.runner.BuildResult
4 | import org.gradle.testkit.runner.TaskOutcome
5 | import ru.vyarus.gradle.plugin.mkdocs.AbstractKitTest
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 07.12.2017
10 | */
11 | class UrlChangeKitTest extends AbstractKitTest {
12 |
13 | def "Check site url change"() {
14 | setup:
15 | build """
16 | plugins {
17 | id 'ru.vyarus.mkdocs'
18 | }
19 |
20 | version = '1.0'
21 |
22 | python.scope = USER
23 | """
24 |
25 | when: "run init"
26 | BuildResult result = run('mkdocsInit')
27 |
28 | then: "docs created"
29 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
30 | File conf = file('src/doc/mkdocs.yml')
31 | conf.exists()
32 |
33 | when: "build site"
34 | conf.text = conf.text.replaceAll(/(?m)^site_url:.*/, "site_url: http://some-url.com")
35 | result = run('mkdocsBuild')
36 |
37 | then: "built"
38 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
39 | result.output =~ /\[python] python(3)? -m mkdocs build -c -d ${isWin ? '"[^"]+"' : '[^(-)]+'} -s/
40 |
41 | file('build/mkdocs/1.0/index.html').exists()
42 | // site_url modified
43 | file('build/mkdocs/1.0/sitemap.xml').text.contains('http://some-url.com/1.0/guide/installation/')
44 | file('build/mkdocs/index.html').exists()
45 | file('build/mkdocs/index.html').text.contains('URL=\'1.0\'')
46 |
47 | then: "config was reverted"
48 | !conf.text.contains('http://some-url.com/1.0')
49 | !file('src/doc/mkdocs.yml.bak').exists()
50 | }
51 |
52 | def "Check disabled site url change"() {
53 | setup:
54 | build """
55 | plugins {
56 | id 'ru.vyarus.mkdocs'
57 | }
58 |
59 | version = '1.0'
60 |
61 | python.scope = USER
62 |
63 | mkdocs.updateSiteUrl = false
64 | """
65 |
66 | when: "run init"
67 | BuildResult result = run('mkdocsInit')
68 |
69 | then: "docs created"
70 | result.task(':mkdocsInit').outcome == TaskOutcome.SUCCESS
71 | File conf = file('src/doc/mkdocs.yml')
72 | conf.exists()
73 |
74 | when: "build site"
75 | conf.text = conf.text.replaceAll(/(?m)^site_url:.*/, "site_url: http://some-url.com")
76 | result = run('mkdocsBuild')
77 |
78 | then: "built"
79 | result.task(':mkdocsBuild').outcome == TaskOutcome.SUCCESS
80 | result.output =~ /\[python] python(3)? -m mkdocs build -c -d ${isWin ? '"[^"]+"' : '[^(-)]+'} -s/
81 |
82 | file('build/mkdocs/1.0/index.html').exists()
83 | // site_url wasn't modified
84 | file('build/mkdocs/1.0/sitemap.xml').text.contains('http://some-url.com/guide/installation/')
85 | file('build/mkdocs/index.html').exists()
86 | file('build/mkdocs/index.html').text.contains('URL=\'1.0\'')
87 |
88 | then: "config was reverted"
89 | !conf.text.contains('http://some-url.com/1.0')
90 | !file('src/doc/mkdocs.yml.bak').exists()
91 | }
92 |
93 | }
94 |
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/util/TemplateUtilsTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.util
2 |
3 | import org.gradle.api.Project
4 | import org.gradle.api.internal.project.ProjectInternal
5 | import ru.vyarus.gradle.plugin.mkdocs.AbstractTest
6 |
7 | /**
8 | * @author Vyacheslav Rusakov
9 | * @since 05.12.2017
10 | */
11 | class TemplateUtilsTest extends AbstractTest {
12 |
13 | def "Check direct access"() {
14 |
15 | when: "copy from classpath"
16 | Project project = project()
17 | TemplateUtils.copy((project as ProjectInternal).fileOperations, '/ru/vyarus/gradle/plugin/mkdocs/template/init/', 'tp', [:])
18 |
19 | then: "copied"
20 | file('tp/mkdocs.yml').exists()
21 | file('tp/docs/index.md').exists()
22 |
23 | when: "no trailing slash"
24 | TemplateUtils.copy((project as ProjectInternal).fileOperations, '/ru/vyarus/gradle/plugin/mkdocs/template/init', 'tp2', [:])
25 |
26 | then: "copied"
27 | file('tp2/mkdocs.yml').exists()
28 | file('tp2/docs/index.md').exists()
29 |
30 | when: "relative path"
31 | TemplateUtils.copy((project as ProjectInternal).fileOperations, 'relative/path', 'tp', [:])
32 | then: "error"
33 | thrown(IllegalArgumentException)
34 |
35 | when: "not existing path"
36 | TemplateUtils.copy((project as ProjectInternal).fileOperations, '/not/existing', 'tp', [:])
37 | then: "error"
38 | thrown(IllegalArgumentException)
39 | }
40 |
41 | def "Check zip access"() {
42 |
43 | when: "build jar"
44 | File templates = new File('src/main/resources/ru/vyarus/gradle/plugin/mkdocs/')
45 | Project project = project()
46 | project.ant.zip(destfile: 'test.jar') {
47 | fileset(dir: templates.absolutePath) {
48 | include(name: '**/*.md')
49 | include(name: '**/*.yml')
50 | include(name: '**/*.html')
51 | }
52 | }
53 |
54 | then: 'built'
55 | File jar = file('test.jar')
56 | jar.exists()
57 |
58 | when: "copy template from jar"
59 | // add to current classpath
60 | URLClassLoader extendedLoader = new URLClassLoader([jar.toURI().toURL()] as URL[], TemplateUtils.getClassLoader())
61 | Thread.currentThread().setContextClassLoader(extendedLoader)
62 |
63 | TemplateUtils.copy((project as ProjectInternal).fileOperations, '/template/init/', 'tp', [:])
64 |
65 | then: "copied"
66 | file('tp/mkdocs.yml').exists()
67 | file('tp/docs/index.md').exists()
68 |
69 | when: "no trailing slash"
70 | TemplateUtils.copy((project as ProjectInternal).fileOperations, '/template/init', 'tp2', [:])
71 |
72 | then: "copied"
73 | file('tp2/mkdocs.yml').exists()
74 | file('tp2/docs/index.md').exists()
75 | }
76 | }
--------------------------------------------------------------------------------
/src/test/groovy/ru/vyarus/gradle/plugin/mkdocs/util/VersionComparatorTest.groovy:
--------------------------------------------------------------------------------
1 | package ru.vyarus.gradle.plugin.mkdocs.util
2 |
3 | import spock.lang.Specification
4 |
5 | /**
6 | * @author Vyacheslav Rusakov
7 | * @since 07.12.2021
8 | */
9 | class VersionComparatorTest extends Specification {
10 |
11 | def "Check strings sorting"() {
12 |
13 | when: "sorting alpha-numeric string, zero last"
14 | List ORDERED = ['1ab', '5ab', '10ab', 'a1b', 'a5b', 'a10b', 'ab1', 'ab5', 'ab10']
15 | def list = new ArrayList(ORDERED)
16 | Collections.shuffle(list)
17 | Collections.sort(list, VersionsComparator.comparingVersions(false))
18 |
19 | then: "order correct"
20 | list == ORDERED
21 |
22 | when: "sorting alpha-numeric string, zero first"
23 | list = new ArrayList(ORDERED)
24 | Collections.shuffle(list)
25 | Collections.sort(list, VersionsComparator.comparingVersions(true))
26 |
27 | then: "order correct"
28 | list == ORDERED
29 | }
30 |
31 | def "Check reversed sorting"() {
32 |
33 | when: "sorting alpha-numeric string, zero last"
34 | List ORDERED = ['1ab', '5ab', '10ab', 'a1b', 'a5b', 'a10b', 'ab1', 'ab5', 'ab10'].reverse()
35 | def list = new ArrayList(ORDERED)
36 | Collections.shuffle(list)
37 | Collections.sort(list, VersionsComparator.comparingVersions(false).reversed())
38 |
39 | then: "order correct"
40 | list == ORDERED
41 |
42 | when: "sorting alpha-numeric string, zero first"
43 | list = new ArrayList(ORDERED)
44 | Collections.shuffle(list)
45 | Collections.sort(list, VersionsComparator.comparingVersions(true).reversed())
46 |
47 | then: "order correct"
48 | list == ORDERED
49 | }
50 |
51 | def "Check double reversed strings sorting"() {
52 |
53 | when: "sorting alpha-numeric string, zero last"
54 | List ORDERED = ['1ab', '5ab', '10ab', 'a1b', 'a5b', 'a10b', 'ab1', 'ab5', 'ab10']
55 | def list = new ArrayList(ORDERED)
56 | Collections.shuffle(list)
57 | Collections.sort(list, VersionsComparator.comparingVersions(false).reversed().reversed())
58 |
59 | then: "order correct"
60 | list == ORDERED
61 |
62 | when: "sorting alpha-numeric string, zero first"
63 | list = new ArrayList(ORDERED)
64 | Collections.shuffle(list)
65 | Collections.sort(list, VersionsComparator.comparingVersions(true).reversed().reversed())
66 |
67 | then: "order correct"
68 | list == ORDERED
69 | }
70 |
71 | def "Check zeros sorting"() {
72 |
73 | when: "sorting alpha-numeric string, zero last"
74 | def list = ['abc 001', 'abc 1', 'abc 01', 'abc 01']
75 | Collections.shuffle(list)
76 | Collections.sort(list, VersionsComparator.comparingVersions(false))
77 |
78 | then: "order correct"
79 | list == ['abc 1', 'abc 01', 'abc 01', 'abc 001']
80 |
81 | when: "sorting alpha-numeric string, zero first"
82 | list = ['abc 001', 'abc 1', 'abc 01', 'abc 01']
83 | Collections.shuffle(list)
84 | Collections.sort(list, VersionsComparator.comparingVersions(true))
85 |
86 | then: "order correct"
87 | list == ['abc 001', 'abc 01', 'abc 01', 'abc 1']
88 |
89 | }
90 |
91 | def "Check versions sorting"() {
92 |
93 | List sorted = ['1.0', '1.3', '1.31', '2.0', '2.1', '2.1-rc1', '2.1-rc2', '2.1-rc12', '2.1.1', '2.1.2', '2.1.12']
94 |
95 | when: "sorting versions"
96 | def list = new ArrayList(sorted)
97 | Collections.shuffle(list)
98 | Collections.sort(list, VersionsComparator.comparingVersions(false))
99 |
100 | then: "sorted"
101 | list == sorted
102 | }
103 | }
104 |
--------------------------------------------------------------------------------