Skip to content
BranchesTags

Repository files navigation

Mongoid::Enum

Build StatusCode Climate

Heavily inspired by DHH's ActiveRecord::Enum, this little library is there to help you cut down the cruft in your models and make the world a happier place at the same time.

A single line will get you fields, accessors, validations and scopes, and a few other bits-and-bobs.

Installation

Add this to your Gemfile:

gem"mongoid-enum"

And then run bundle install.

Usage

classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end

Aaaaaaand then you get things like:

payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved

Features

Field

Your enum value is stored as either a Symbol, or an Array (when storing multiple values). The actual field name has a leading underscore (e.g.: _status), but is also aliased with its actual name for you convenience.

Accessors

Your enums will get getters-and-setters with the same name. So using the Payment example above:

payment.status=:declinedpayment.status# => :declined

And you also get bang(!) and query(?) methods for each of the values in your enum (see this example.

Constants

For each enum, you'll also get a constant named after it. This is to help you elsewhere in your app, should you need to display, or leverage the list of values. Using the above example:

Payment::STATUS# => [:pending, :approved, :declined]

Validations

Enum values are automatically validated against the list. You can disable this behaviour (see below).

Scopes

A scope added for each of your enum's values. Using the example above, you'd automatically get:

Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria

Options

Default value

If not specified, the default will be the first in your list of values (:pending in the example above). You can override this with the :default option:

enum:roles,[:manager,:administrator],:default=>""

Multiple values

Sometimes you'll need to store multiple values from your list, this couldn't be easier:

enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]

Since the underlying datatype for storing values is an array, if you need to specify default(s), ensure you use an array:

enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default

Validations

Validations are baked in by default, and ensure that the value(s) set in your field are always from your list of options. If you need more complex validations, or you just want to throw caution to the wind, you can turn them off:

enum:status,[:up,:down],:validate=>false

Issues and Feature Requests

If you have any problems, or you have a suggestion, please submit an issue (and a failing test, if you can). Pull requests and feature requests are alwasy welcome and greatly appreciated.

About

Sweet enum sugar for your Mongoid documents

Resources

Readme
MIT license
Activity
Custom properties

Stars

1 star

Watchers

1 watching

Forks

9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
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 - ClusterTV/mongoid-enum: Sweet enum sugar for your Mongoid documents · GitHub
Skip to content
BranchesTags
Repository files navigation
Mongoid::Enum
Build StatusCode Climate
Heavily inspired by DHH's
ActiveRecord::Enum, this little library is
there to help you cut down the cruft in your models and make the
world a happier place at the same time.
A single line will get you fields, accessors, validations and scopes,
and a few other bits-and-bobs.
Installation
Add this to your Gemfile:
gem"mongoid-enum"
And then run bundle install.
Usage
classPaymentincludeMongoid::DocumentincludeMongoid::Enumenum:status,[:pending,:approved,:declined]end
Aaaaaaand then you get things like:
payment=Payment.createpayment.status# => :pendingpayment.approved!# => :approvedpayment.pending?# => :falsePayment.approved# => Mongoid::Criteria for payments with status == :approved
Features
Field
Your enum value is stored as either a Symbol, or an Array (when storing
multiple values). The actual field name has a leading underscore (e.g.:
_status), but is also aliased with its actual name for you
convenience.
Accessors
Your enums will get getters-and-setters with the same name. So using the
Payment example above:
payment.status=:declinedpayment.status# => :declined
And you also get bang(!) and query(?) methods for each of the values in
your enum (see this example.
Constants
For each enum, you'll also get a constant named after it. This is to
help you elsewhere in your app, should you need to display, or leverage
the list of values. Using the above example:
Payment::STATUS# => [:pending, :approved, :declined]
Validations
Enum values are automatically validated against the list. You can
disable this behaviour (see below).
Scopes
A scope added for each of your enum's values. Using the example above,
you'd automatically get:
Payment.pending# => Mongoid::CriteriaPayment.approved# => Mongoid::CriteriaPayment.declined# => Mongoid::Criteria
Options
Default value
If not specified, the default will be the first in your list of values
(:pending in the example above). You can override this with the
:default option:
enum:roles,[:manager,:administrator],:default=>""
Multiple values
Sometimes you'll need to store multiple values from your list, this
couldn't be easier:
enum:roles,[:basic,:manager,:administrator],:multiple=>true# ...user=User.createuser.roles << :basicuser.roles << :manageruser.save!user.manager?# => trueuser.administrator?# => falseuser.roles# => [:basic, :manager]
Since the underlying datatype for storing values is an array, if you
need to specify default(s), ensure you use an array:
enum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[:author,:editor]# two defaultsenum:roles,[:noob,:author,:editor],:multiple=>true,:default=>[]# no default
Validations
Validations are baked in by default, and ensure that the value(s) set in
your field are always from your list of options. If you need more
complex validations, or you just want to throw caution to the wind, you
can turn them off:
enum:status,[:up,:down],:validate=>false
Issues and Feature Requests
If you have any problems, or you have a suggestion, please submit an
issue (and a failing
test, if you can). Pull requests and feature requests are alwasy welcome
and greatly appreciated.
About
Sweet enum sugar for your Mongoid documents
Resources
Readme
MIT license
Activity
Custom properties
Stars
1 star
Watchers
1 watching
Forks
9 forks
Report repository
Releases
Packages
Contributors
Languages