repokeeper 0.3.0 → 0.4.0

package/README.md

@@ -5,8 +5,9 @@ files, editor and gitignore settings, Dependabot, CI and releases — applied on
 the standard evolves.
 
 > Status: early development. Supported stacks: Node.js (including NestJS), Python, Dart and
-> Flutter, shell and PowerShell scripts, Java (Maven and Gradle) and .NET, each with CI and releases.
-> GitHub settings are on the way. See the [design](docs/superpowers/specs/2026-09-25-repokeeper-design.md).
+> Flutter, shell and PowerShell scripts, Java (Maven and Gradle), Kotlin, .NET, Go, Rust, PHP and
+> Ruby, each with CI and releases, plus GitHub settings through `repokeeper github apply`. See the
+> [design](docs/superpowers/specs/2026-09-25-repokeeper-design.md).
 
 ## Usage
 
@@ -51,8 +52,10 @@ Requires Node.js 22.12 or newer.
 
 `ci.yml` and `release.yml` call reusable workflows from this repository (`stack-node.yml`,
 `commitlint.yml`, `release-please.yml`) at the moving major tag, so fixes reach every repository
-without a pull request. repokeeper owns the `name`, `on` and `permissions` keys and the jobs it
-adds; jobs you add yourself are left alone, and so is the formatting of the rest of the file.
+without a pull request. repokeeper owns the `name`, `on`, `permissions` and `concurrency` keys and
+the jobs it adds; jobs you add yourself are left alone, and so is the formatting of the rest of the
+file. A new push to a pull request cancels that pull request's earlier `ci` run; runs on the default
+branch always finish.
 
 The script stack runs ShellCheck and `shfmt -d` on `*.sh` (format with `shfmt -w` before pushing)
 and PSScriptAnalyzer on `*.ps1`, which fails on errors and warnings (not on information-level rules). To

package/dist/config/types.js

@@ -1,4 +1,16 @@
-export const STACK_IDS = ["node", "python", "dart", "script", "java", "dotnet"];
+export const STACK_IDS = [
+    "node",
+    "python",
+    "dart",
+    "script",
+    "java",
+    "dotnet",
+    "go",
+    "rust",
+    "kotlin",
+    "php",
+    "ruby",
+];
 /** The branch workflows run on and contributors branch from: `github.default_branch`, or `main`. */
 export function defaultBranch(config) {
     const branch = config.github?.default_branch;

package/dist/platforms/github.js

@@ -132,6 +132,13 @@ export const githubPlatform = {
             workflowKey("ci", path, ["name"], "ci"),
             workflowKey("ci", path, ["on"], { pull_request: null, push: { branches: [defaultBranch(ctx.config)] } }),
             workflowKey("ci", path, ["permissions"], { contents: "read" }),
+            // a new push to a pull request makes its earlier run pointless; runs on the default branch always finish
+            workflowKey("ci", path, ["concurrency"], {
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: GitHub Actions expressions
+                group: "${{ github.workflow }}-${{ github.ref }}",
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: GitHub Actions expressions
+                "cancel-in-progress": "${{ github.event_name == 'pull_request' }}",
+            }),
             ...jobs,
         ];
     },
@@ -151,6 +158,7 @@ export const githubPlatform = {
                             "bump-minor-pre-major": true,
                             "include-component-in-tag": false,
                             ...(release.extraFiles && release.extraFiles.length > 0 ? { "extra-files": release.extraFiles } : {}),
+                            ...(release.versionFile ? { "version-file": release.versionFile } : {}),
                         },
                     },
                 }),

package/dist/stacks/go.js

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { checkKeys, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+const GOFMT = 'test -z "$(gofmt -l .)" || { gofmt -l .; exit 1; }';
+export const goStack = {
+    id: "go",
+    detect: (root) => existsSync(join(root, "go.mod")),
+    async resolve(_root, options = {}) {
+        checkKeys("go", options, OPTION_KEYS);
+        return {
+            id: "go",
+            staged: [{ name: "go:gofmt", glob: "*.go", run: "gofmt -w {staged_files}" }],
+            test: "go test ./...",
+            install: "go mod download",
+            gitignore: ["Go"],
+            dependabot: ["gomod"],
+            ci: {
+                workflow: "stack-go.yml",
+                with: {
+                    "go-versions": JSON.stringify(stringList("go", options, "versions") ?? ["stable"]),
+                    os: JSON.stringify(stringList("go", options, "os") ?? ["ubuntu-latest"]),
+                    commands: JSON.stringify([GOFMT, "go vet ./...", "go test ./..."]),
+                },
+            },
+            // Go modules are versioned by their tags; the manifest starts from the latest one
+            release: { type: "go", version: null },
+        };
+    },
+};

package/dist/stacks/gradle.js

@@ -0,0 +1,16 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { readText } from "./support.js";
+export const GRADLE_FILES = ["build.gradle", "build.gradle.kts"];
+/** The build command (wrapper when present) and release info of a Gradle project. */
+export async function gradleBuild(root) {
+    const wrapper = existsSync(join(root, "gradlew"));
+    const properties = await readText(root, "gradle.properties");
+    const version = properties ? (/^version\s*=\s*(\S+)/m.exec(properties)?.[1] ?? null) : null;
+    return {
+        command: wrapper ? "./gradlew check" : "gradle check",
+        wrapper,
+        // release-please's generic updater changes gradle.properties once it carries x-release-please markers
+        release: { type: "simple", version, ...(properties !== null ? { extraFiles: ["gradle.properties"] } : {}) },
+    };
+}

package/dist/stacks/index.js

@@ -1,9 +1,14 @@
 import { STACK_IDS } from "../config/types.js";
 import { dartStack } from "./dart.js";
 import { dotnetStack } from "./dotnet.js";
+import { goStack } from "./go.js";
 import { javaStack } from "./java.js";
+import { kotlinStack } from "./kotlin.js";
 import { nodeStack } from "./node.js";
+import { phpStack } from "./php.js";
 import { pythonStack } from "./python.js";
+import { rubyStack } from "./ruby.js";
+import { rustStack } from "./rust.js";
 import { scriptStack } from "./script.js";
 const PACKS = {
     node: nodeStack,
@@ -12,12 +17,20 @@ const PACKS = {
     script: scriptStack,
     java: javaStack,
     dotnet: dotnetStack,
+    go: goStack,
+    rust: rustStack,
+    kotlin: kotlinStack,
+    php: phpStack,
+    ruby: rubyStack,
 };
 export function getStackPack(id) {
     return PACKS[id];
 }
 export async function detectStacks(root) {
-    const found = STACK_IDS.filter((id) => PACKS[id].detect(root));
+    let found = STACK_IDS.filter((id) => PACKS[id].detect(root));
+    // a Kotlin build is also a Gradle build; one CI job runs it
+    if (found.includes("kotlin"))
+        found = found.filter((id) => id !== "java");
     // scripts beside another stack belong to that stack; the script pack is for script-only repositories
     return found.length > 1 ? found.filter((id) => id !== "script") : found;
 }

package/dist/stacks/java.js

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { gradleBuild } from "./gradle.js";
 import { checkKeys, readText, stringList } from "./support.js";
 const OPTION_KEYS = ["versions", "os"];
 /** The project's own <version>: parent, dependency and plugin versions are removed first. */
@@ -22,11 +23,7 @@ export const javaStack = {
             release = { type: "maven", version: mavenVersion((await readText(root, "pom.xml")) ?? "") };
         }
         else {
-            command = has("gradlew") ? "./gradlew check" : "gradle check";
-            const properties = await readText(root, "gradle.properties");
-            const version = properties ? (/^version\s*=\s*(\S+)/m.exec(properties)?.[1] ?? null) : null;
-            // release-please's generic updater changes gradle.properties once it carries x-release-please markers
-            release = { type: "simple", version, ...(properties !== null ? { extraFiles: ["gradle.properties"] } : {}) };
+            ({ command, release } = await gradleBuild(root));
         }
         return {
             id: "java",

package/dist/stacks/kotlin.js

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { UsageError } from "../errors.js";
+import { GRADLE_FILES, gradleBuild } from "./gradle.js";
+import { checkKeys, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+// plugin ids, the kotlin() shorthand and version-catalog aliases; org.jetbrains.kotlinx is a library, not the plugin
+const KOTLIN = /\bkotlin\(\s*"|org\.jetbrains\.kotlin[."']|libs\.plugins\.kotlin\b/;
+const ANDROID = /com\.android\.(application|library)|libs\.plugins\.android\b/;
+/** The root Gradle build files, with `//` comments removed. */
+function buildFiles(root) {
+    return GRADLE_FILES.flatMap((file) => {
+        try {
+            return [{ file, text: readFileSync(join(root, file), "utf8").replace(/\/\/.*$/gm, "") }];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+/** Whether a Gradle build at the root applies a Kotlin plugin. */
+export const usesKotlin = (root) => buildFiles(root).some(({ text }) => KOTLIN.test(text));
+export const kotlinStack = {
+    id: "kotlin",
+    detect: usesKotlin,
+    async resolve(root, options = {}) {
+        checkKeys("kotlin", options, OPTION_KEYS);
+        const android = buildFiles(root).find(({ text }) => ANDROID.test(text));
+        if (android) {
+            throw new UsageError(`${android.file} is an Android project, which needs the Android SDK the CI runners don't have; leave kotlin out of stacks`);
+        }
+        const { command, release, wrapper } = await gradleBuild(root);
+        return {
+            id: "kotlin",
+            // ktlint or Spotless run through the build, like Spotless for java
+            staged: [],
+            test: command,
+            install: null,
+            gitignore: ["Kotlin", "Gradle"],
+            dependabot: ["gradle"],
+            ci: {
+                workflow: "stack-java.yml",
+                with: {
+                    "java-versions": JSON.stringify(stringList("kotlin", options, "versions") ?? ["17", "21"]),
+                    os: JSON.stringify(stringList("kotlin", options, "os") ?? ["ubuntu-latest"]),
+                    "build-tool": "gradle",
+                    "gradle-version": wrapper ? "" : "current",
+                    commands: JSON.stringify([command]),
+                },
+            },
+            release,
+        };
+    },
+};

package/dist/stacks/php.js

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { UsageError } from "../errors.js";
+import { checkKeys, readText, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+export const phpStack = {
+    id: "php",
+    detect: (root) => existsSync(join(root, "composer.json")),
+    async resolve(root, options = {}) {
+        checkKeys("php", options, OPTION_KEYS);
+        const has = (path) => existsSync(join(root, path));
+        let composer;
+        try {
+            composer = JSON.parse((await readText(root, "composer.json")) ?? "{}");
+        }
+        catch (error) {
+            throw new UsageError(`composer.json could not be read: ${error.message}`);
+        }
+        const csFixer = has(".php-cs-fixer.dist.php") || has(".php-cs-fixer.php");
+        const phpstan = has("phpstan.neon") || has("phpstan.neon.dist") || has("phpstan.dist.neon");
+        const test = composer.scripts?.test
+            ? "composer test"
+            : has("phpunit.xml") || has("phpunit.xml.dist") || has("phpunit.dist.xml")
+                ? "vendor/bin/phpunit"
+                : null;
+        return {
+            id: "php",
+            staged: csFixer
+                ? [{ name: "php:cs-fixer", glob: "*.php", run: "vendor/bin/php-cs-fixer fix {staged_files}" }]
+                : [],
+            test,
+            install: "composer install",
+            gitignore: ["Composer"],
+            dependabot: ["composer"],
+            ci: {
+                workflow: "stack-php.yml",
+                with: {
+                    "php-versions": JSON.stringify(stringList("php", options, "versions") ?? ["8.3", "8.4"]),
+                    os: JSON.stringify(stringList("php", options, "os") ?? ["ubuntu-latest"]),
+                    "install-command": "composer install --no-interaction --no-progress",
+                    commands: JSON.stringify([
+                        // --strict would fail on warnings such as a missing license or the version field release-please writes
+                        "composer validate --no-check-publish",
+                        ...(csFixer ? ["vendor/bin/php-cs-fixer fix --dry-run --diff"] : []),
+                        ...(phpstan ? ["vendor/bin/phpstan analyse --no-progress"] : []),
+                        ...(test ? [test] : []),
+                    ]),
+                },
+            },
+            release: { type: "php", version: composer.version ?? null },
+        };
+    },
+};

package/dist/stacks/python.js

@@ -1,14 +1,10 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { checkKeys, filesMatching, optionalString, readText, stringList } from "./support.js";
+import { checkKeys, filesMatching, optionalString, readText, stringList, tomlSection } from "./support.js";
 const OPTION_KEYS = ["versions", "os", "test"];
 /** The `version = "…"` of the `[project]` table, if any. */
 function projectVersion(pyproject) {
-    return /^version\s*=\s*"([^"]+)"/m.exec(section(pyproject, "project"))?.[1] ?? null;
-}
-/** The body of the `[name]` table of a TOML file, or "". */
-function section(toml, name) {
-    return toml.split(/^\[/m).find((part) => part.startsWith(`${name}]`)) ?? "";
+    return /^version\s*=\s*"([^"]+)"/m.exec(tomlSection(pyproject, "project"))?.[1] ?? null;
 }
 export const pythonStack = {
     id: "python",
@@ -21,7 +17,7 @@ export const pythonStack = {
         const mypyIni = (await readText(root, "mypy.ini")) ?? "";
         const mypy = has("mypy.ini") || pyproject.includes("[tool.mypy]");
         // a config that names its files decides what mypy checks; otherwise check the whole tree
-        const mypyFiles = /^files\s*=/m.test(mypyIni) || /^files\s*=/m.test(section(pyproject, "tool.mypy"));
+        const mypyFiles = /^files\s*=/m.test(mypyIni) || /^files\s*=/m.test(tomlSection(pyproject, "tool.mypy"));
         const hasTests = has("tests") || has("test") || filesMatching(root, ".", /^test_.*\.py$/).length > 0;
         const customTest = optionalString("python", options, "test");
         const pytest = customTest === undefined && hasTests;

package/dist/stacks/ruby.js

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { checkKeys, filesMatching, readText, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+// only the gem's own version: not MINIMUM_RUBY_VERSION, required_ruby_version or a computed value
+const VERSION_CONSTANT = /^\s*VERSION\s*=\s*["']([^"']+)["']/m;
+const GEMSPEC_VERSION = /\.version\s*=\s*["']([^"']+)["']/;
+/** A `VERSION = "x.y.z"` in lib/<name>/version.rb, else the gemspec's `s.version = "x.y.z"`. */
+async function rubyRelease(root) {
+    for (const dir of filesMatching(root, "lib", /^[^.]+$/)) {
+        const path = `lib/${dir}/version.rb`;
+        const version = VERSION_CONSTANT.exec((await readText(root, path)) ?? "")?.[1];
+        if (version)
+            return { type: "ruby", version, versionFile: path };
+    }
+    for (const spec of filesMatching(root, ".", /\.gemspec$/)) {
+        const version = GEMSPEC_VERSION.exec((await readText(root, spec)) ?? "")?.[1];
+        // release-please's ruby strategy only bumps version.rb; the generic updater bumps the gemspec
+        if (version)
+            return { type: "ruby", version, extraFiles: [spec] };
+    }
+    return { type: "ruby", version: null };
+}
+export const rubyStack = {
+    id: "ruby",
+    detect: (root) => existsSync(join(root, "Gemfile")),
+    async resolve(root, options = {}) {
+        checkKeys("ruby", options, OPTION_KEYS);
+        const has = (path) => existsSync(join(root, path));
+        const rubocop = has(".rubocop.yml");
+        const test = has("spec") ? "bundle exec rspec" : has("Rakefile") && has("test") ? "bundle exec rake test" : null;
+        return {
+            id: "ruby",
+            staged: rubocop
+                ? [{ name: "ruby:rubocop", glob: "*.rb", run: "bundle exec rubocop --autocorrect {staged_files}" }]
+                : [],
+            test,
+            install: "bundle install",
+            gitignore: ["Ruby"],
+            dependabot: ["bundler"],
+            ci: {
+                workflow: "stack-ruby.yml",
+                with: {
+                    "ruby-versions": JSON.stringify(stringList("ruby", options, "versions") ?? ["3.3", "3.4"]),
+                    os: JSON.stringify(stringList("ruby", options, "os") ?? ["ubuntu-latest"]),
+                    "install-command": "bundle install",
+                    commands: JSON.stringify([...(rubocop ? ["bundle exec rubocop"] : []), ...(test ? [test] : [])]),
+                },
+            },
+            release: await rubyRelease(root),
+        };
+    },
+};

package/dist/stacks/rust.js

@@ -0,0 +1,39 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { checkKeys, readText, stringList, tomlSection } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+export const rustStack = {
+    id: "rust",
+    detect: (root) => existsSync(join(root, "Cargo.toml")),
+    async resolve(root, options = {}) {
+        checkKeys("rust", options, OPTION_KEYS);
+        const cargo = (await readText(root, "Cargo.toml")) ?? "";
+        const pkg = tomlSection(cargo, "package");
+        const version = /^version\s*=\s*"([^"]+)"/m.exec(pkg)?.[1] ?? null;
+        // a workspace root without its own package has nothing for release-please's rust updater to bump
+        const release = pkg ? { type: "rust", version } : { type: "simple", version: null };
+        return {
+            id: "rust",
+            staged: [{ name: "rust:fmt", glob: "*.rs", run: "cargo fmt --all" }],
+            test: "cargo test",
+            install: "cargo fetch",
+            gitignore: ["Rust"],
+            dependabot: ["cargo"],
+            ci: {
+                workflow: "stack-rust.yml",
+                with: {
+                    "rust-versions": JSON.stringify(stringList("rust", options, "versions") ?? ["stable"]),
+                    os: JSON.stringify(stringList("rust", options, "os") ?? ["ubuntu-latest"]),
+                    commands: JSON.stringify([
+                        "cargo fmt --all --check",
+                        "cargo clippy --workspace --all-targets -- -D warnings",
+                        "cargo test --workspace --all-targets",
+                        // --all-targets leaves doctests out, and --doc fails when there is no library to document
+                        ...(existsSync(join(root, "src/lib.rs")) ? ["cargo test --workspace --doc"] : []),
+                    ]),
+                },
+            },
+            release,
+        };
+    },
+};

package/dist/stacks/support.js

@@ -48,3 +48,7 @@ export async function readText(root, file) {
         return null;
     }
 }
+/** The body of the `[name]` table of a TOML file, or "". */
+export function tomlSection(toml, name) {
+    return toml.split(/^\[/m).find((part) => part.startsWith(`${name}]`)) ?? "";
+}

package/dist/version.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 export const PACKAGE_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 /** The standard this build of repokeeper applies. Bump it whenever generated output changes. */
-export const STANDARD_VERSION = "1.2.2";
+export const STANDARD_VERSION = "1.3.0";
 export const TOOL_VERSIONS = {
     lefthook: "2.1.14",
     commitlintCli: "21.2.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repokeeper",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Keep every repository on one maintained standard: commits, git hooks, CI, releases, dependency updates and repo settings.",
   "type": "module",
   "bin": {

package/templates/gitignore/Composer.gitignore

@@ -0,0 +1,6 @@
+composer.phar
+/vendor/
+
+# Commit your application's lock file https://getcomposer.org/doc/01-basic-usage.md#commit-your-composer-lock-file-to-version-control
+# You may choose to ignore a library lock file http://getcomposer.org/doc/02-libraries.md#lock-file
+# composer.lock

package/templates/gitignore/Go.gitignore

@@ -0,0 +1,32 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Code coverage profiles and other test artifacts
+*.out
+coverage.*
+*.coverprofile
+profile.cov
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# Editor/IDE
+# .idea/
+# .vscode/

package/templates/gitignore/Kotlin.gitignore

@@ -0,0 +1,27 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*
+
+# Kotlin Gradle plugin data, see https://kotlinlang.org/docs/whatsnew20.html#new-directory-for-kotlin-data-in-gradle-projects
+.kotlin/

package/templates/gitignore/Ruby.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

package/templates/gitignore/Rust.gitignore

@@ -0,0 +1,24 @@
+# Generated by Cargo
+# will have compiled files and executables
+debug
+target
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# Generated by cargo mutants
+# Contains mutation testing data
+**/mutants.out*/
+
+# rustc will dump stack traces when hitting an internal compiler error to PWD
+rustc-ice-*.txt
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/