BranchesTags

Repository files navigation

FixCache

Introduction

FixCache is a github app implementation of FixCache with git commit history.

FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.

It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.

On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.

  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.

screenshot

The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:

  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon

Installation

  • Install it to your repositories from here

Permissions

Repository permissions

The app has access to the following repository permissions:

  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write

Events

The app is subscribed to the following events:

  • Pull request
  • Push

Configuration

The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.

Github config

  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook

Fix cache config

  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files

Default

Following default values are used in the current version of the app:

  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md

If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.

Deploying your own FixCache

FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.

Clone the repository

  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.

Deploy on Deta

This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.

If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.

  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new

You should see the output that the application has been created and the dependencies have been installed.

  • After installing the app, enter
$ deta details

You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.

  • Lastly disable auth by entering:
$ deta auth disable

We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.

Create a github app

A comprehensive guide on creating a github app is available here.

  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).

Setting up the webhook

In Webhook URL, type the endpoint from the output to deta details.

Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.

Permissions and Events

When choosing the permissions for the app, you will need to provide the app with following repository permissions:

  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write

The app is subscribed to the following events:

  • Pull request
  • Push

Generate the private key

After creating the github app, go to your app's General settings and generate a private key.

Save the private key in the your cloned directory in a file. This is required for authentication.

Make sure you do not commit this file to a public repository.

Configure the app

App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables. A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.

  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files

Deploy the changes and the configuration

First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,

$ deta deploy

Next, deploy the configuration in the .env with,

$ deta update -e .env

You should see that the environment variables have been successfully updated.

Install

The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.

About

Github app that keeps track of bug-prone files from commit history.

Topics

code-reviewdetagithub-appnodejs

Resources

Readme
MIT license
Activity

Stars

84 stars

Watchers

2 watching

Forks

2 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
FixCache
Introduction
FixCache is a github app implementation of FixCache with git commit history.
FixCache can be useful for prioritizing verification, validation and testing resources on the most fault-prone files.
It keeps track of bug fix commits pushed to a configurabletracked branch of a repository and maintains a fix-sized cache of file entities most prone to bugs. The bug fix commits are identified by the fix keywords provided in the configuration.
On pull requests, it fetches the cache and updates the pull requests with information about the files present in the cache if the pull request updates these files.
  • it adds a label fix cache to the pull request.
  • it adds a comment with the filenames present in the cache and the respective number of cache hits.
screenshot
The algorithm is executed over the commit history of the project. The paper assumes four kinds of localities that bugs occur in:
  • Changed-entity locality : if an entity was changed recently, it will tend to introduce faults soon
  • New-entity locality: if an entity has been added recently, it will tend to introduce faults soon
  • Temporal locality: if an entity introduced a fault recently, it will tend to introduce other faults soon
  • Spatial locality: if an entity introduced a fault recently, "nearby" entities will also tend to introduce faults soon
Installation
  • Install it to your repositories from here
Permissions
Repository permissions
The app has access to the following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
Events
The app is subscribed to the following events:
  • Pull request
  • Push
Configuration
The app (for now) uses a .env file for configuration. A sample config is shown in env.sample.
Github config
  • GITHUB_APP_ID : the github application id
  • PRIVATE_KEY_PATH: the path to the private key
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
Fix cache config
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Default
Following default values are used in the current version of the app:
  • CACHE_SIZE: 25
  • HISTORY_SIZE: 30
  • FIX_KEY_WORDS: fix
  • TRACKED_BRANCH: master
  • SKIP_PATHS: test,.md
If this configuration is not suitable for your repositories, you can deploy your own FixCache with the required configuration.
Deploying your own FixCache
FixCache is deployed on Deta micros. The following steps show how to deploy your own FixCache as a github app with custom configuration.
Clone the repository
  • Clone the repository with git clone https://github.com/aavshr/fixCache.git.
Deploy on Deta
This deployment is for Deta micros. You will need to have signed up for deta and the deta cli installed.
If you want to deploy on another platform, you will need to modify the code slightly and then set up the respective configuration for deployment to other platforms.
  • After you have cloned the repository, change the directory to the cloned directory and enter in your terminal
$ deta new
You should see the output that the application has been created and the dependencies have been installed.
  • After installing the app, enter
$ deta details
You should see details about your application in your output. The endpoint shown will be needed later to add as the webhook url in our github app.
  • Lastly disable auth by entering:
$ deta auth disable
We will use a webhook secret to verify that the events are coming from github on our webhook endpoint.
Create a github app
A comprehensive guide on creating a github app is available here.
  • Go to your developer settings (it's under settings on the dropdown menu when you click your profile on github) and create a new github app. Provide a name (and description if you want).
Setting up the webhook
In Webhook URL, type the endpoint from the output to deta details.
Generate a long secure random string (there are services online that do this) and use that as the Webhook Secret. Keep hold of this secret as you will need it to set up the configuration later.
Permissions and Events
When choosing the permissions for the app, you will need to provide the app with following repository permissions:
  • Contents: Read-only
  • Metadata : Read-only
  • Pull requests: Read & write
The app is subscribed to the following events:
  • Pull request
  • Push
Generate the private key
After creating the github app, go to your app's General settings and generate a private key.
Save the private key in the your cloned directory in a file. This is required for authentication.
Make sure you do not commit this file to a public repository.
Configure the app
App configuration (for now) is simply done through environment variables. Create a new file .env in the cloned directory and provide it with the following variables.
A sample env.sample is present in the repository to see the format of the file. Make sure you do not expose your .env file publicly.
  • GITHUB_APP_ID : the github app id, you can find this in your github app's general settings.
  • PRIVATE_KEY_PATH: the path to the private key file you saved in the earlier step.
  • WEBHOOK_SECRET: the webhook secret for the app's webhook
  • CACHE_SIZE: the size of the fix cache i.e number of files stored in the cache
  • HISTORY_SIZE: the number of days to load commit history from on installation
  • FIX_KEY_WORDS: Keywords in a fix commit separated by commas eg. fix,fixed
  • TRACKED_BRANCH: the main branch to track pushes on
  • SKIP_PATHS: paths to skip/not store in the fix cache like test files
Deploy the changes and the configuration
First change the directory to the root of the cloned directory (if you are not there already) and deploy the changes with,
$ deta deploy
Next, deploy the configuration in the .env with,
$ deta update -e .env
You should see that the environment variables have been successfully updated.
Install
The FixCache should be now be deployed completely and ready to function. You can install the app to your repositories in the Install App page of your github app.
About
Github app that keeps track of bug-prone files from commit history.
Topics
code-reviewdetagithub-appnodejs
Resources
Readme
MIT license
Activity
Stars
84 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages