Skip to content
BranchesTags

Repository files navigation

Enabler

Granular Feature Enabling For Ruby Apps

There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies

The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.

Installation

Add this line to your application's Gemfile:

gem 'enabler'

And then execute:

$ bundle

Or install it yourself as:

$ gem install enabler

Usage

Enable a feature

Enabler.enable!:new_feature,User.first

Disable a feature

Enabler.disable!:new_feature,User.first

Check if feature enabled for object

classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend

Configuration

Currently there is only one storage adapter - Redis

Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend

Rules

Rules are useful if you want to set a feature globally based on an objects state. For example enabling employee access to new features before rolling out to the public

Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend

Callbacks

You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.

Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend

TODO

  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes

Contributing

  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request

About

Feature enabler

Resources

Readme
Activity

Stars

3 stars

Watchers

2 watching

Forks

1 fork
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
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;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - awsmsrc/enabler: Feature enabler · GitHub
Skip to content
BranchesTags
Repository files navigation
Enabler
Granular Feature Enabling For Ruby Apps
There are a fair few feature flip gems out there. None of them had exactly the feature set I needed. Most either flipped features globally or worked only on the basis of a user class. I needed to be able to switch features on for users, teams of users OR entirely different models altogether E.G companies
The goal of this gem is to enable very granular control of which users/teams/companies/customers/cats have access to which features.
Installation
Add this line to your application's Gemfile:
gem 'enabler'

And then execute:
$ bundle

Or install it yourself as:
$ gem install enabler

Usage
Enable a feature
Enabler.enable!:new_feature,User.first
Disable a feature
Enabler.disable!:new_feature,User.first
Check if feature enabled for object
classNewFeatureController < ActionController::Basedefshowredirect_to'/home'unlessEnabler.enabled?:new_feature,current_userrender_super_secret_awesome_new_featureendend
Configuration
Currently there is only one storage adapter - Redis
Enabler.configuredopersistenceEnabler::Storage::Redis.new($redis)after_enabling:new_featuredo |model|
send_notification_email(model)endafter_disabling:new_featuredo |model|
model.remove_feature_specific_db_recordsendrule:drivedo |model|
model.admin?endend
Rules
Rules are useful if you want to set a feature globally based on an objects state.
For example enabling employee access to new features before rolling out to the public
Enabler.configuredorule:new_featuredo |object|
object.is_employee?endend
Callbacks
You can define callbacks that are triggered after enabling or disabling features, this is useful fir things like sending emails or adding feature specific records to the db.
Enabler.configuredoafter_enabling:new_featuredo |model|
send_notification_email(model)endend
TODO
  • caching
  • group definitions
  • rake task to add feature for percentage of users
  • ActiveRecord storage
  • Mongo storage
  • In memory storage
  • scopes
Contributing
  1. Fork it ( https://github.com/[my-github-username]/enabler/fork )
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request
About
Feature enabler
Resources
Readme
Activity
Stars
3 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages