Run this in your browser console to get a readout on which words you (or whoever) need to break out a thesaurus for.

Might have gone a little overboard with the modules, but I think it makes it more readable.

Confirm Leave: sure?

Will prompt before page unloads. Good for when you’re filling out a form or something and don’t want to accidentally close the page.

URL Param Cleanup*: ?=?

Takes a URL?that=looks&like=this, parses, and returns

{
    "that": "looks",
    "like": "this"
}

HTML Prompt*: html?

Prompts for and displays your HTML.

Millisecond Param: ?123

May or may not bust any caches.

* These two are data URIs and thus aren't probably technically bookmarklets.

Oh, and...

• My auto-updating text editor via data URI, relabeled to ...
• My addCSS to inject arbitrary CSS
• jQuerify to inject jQuery

That’s why I’m so glad to say that I’m passing the torch to another developer. David is a smart, talented gent and (if his git commits to the project are any indication) is the perfect guy to take over OneFileCMS.

His repo: https://github.com/Self-Evident/OneFileCMS

Thank you, David!

Instructions: use my Add CSS Bookmarklet

* What, you ask? Oh, anything, I suppose. Speech disfluencies, annoying sounds, the number of times I think about Dorito shell tacos every day, etc.

http://jsfiddle.net/rocktronica/seHze/
https://gist.github.com/2156283

Been working on this the last couple days. It’s “a trivial but hopefully useful PHP file modification notifier” that can holler if your files get modified without you knowing. It can be run via browser or command line.

https://github.com/rocktronica/modglob

Relative to its location, modglob will recursively check folders for PHP files then order them by their last modification date. You can reselect by those modified within the last hour, day, week, month, infinity.

URL Params and CLI Arguments

• Limit
  Number of files and folders to stop at. Default is a ridiculous million.
• Hours
  Default is 1. Crank it up to 24 if you’ll be running the script daily, etc.
• Format
  Options: text, html, dump. Will try to detect and show HTML/text for web/CLI, respectively. Dump is good for testing.
• Mail
  Give it a valid email address, and it will email the text results. If none, it won’t. This is handy when the script is run via cron job.
• Ignore
  Array of folders to ignore if it finds them. I’ve got a “cache” folder with a billion text files in it, so that’s the default.

CLI args are the first letters of each param, hyphened. So:
php modglob.php -h 168 -i foo -l 100
will show all files modified within the last week (168 = 24 * 7), ignoring the “foo” folder, and stopping when it’s seen 100 files or folders.

Attribution, License, Responsibility

Made with PHP, jQuery, TinySort. Requires PHP5, I’d bet. MIT/GPL licensed or as components allow.

Please be careful with how you use this. Obviously, indexing a gergillion files on a live server can use up some resources. Try to test in an inconspicuous place first, set proper limit and ignore variables, etc. Always be prepared!

Comments and concerns welcome via the project’s issues page.

Link: https://github.com/rocktronica/modglob

This is my little attempt at a needlessly prettified GitHub profile… It’s mostly so I can rest easy knowing my pages apps’ root is something that will tie them all together hierarchically.

http://rocktronica.github.com/

Technical Tidbits

• Apple-ish black linen texture from Subtle Patterns lazily base64′d right into style.css
• Lots of pseudo selecting table elements to get them to look nice
• Bitter serif font via Google Webfonts
• Uses jQuery, h5bp, json2, mustache, and -prefix-free
• Most of the HTML and CSS written with tmpltr
• Message and Follow buttons are placebos that just link to the normal profile page because:
  • On the GH main site, URIs for following exist but are handled with Ajax and so don’t degrade. That’s probably rightfully a very low priority.
  • Messaging is handled with plaintext email addresses, normally only visible if you’re logged in. BUT their API shows them w/o authentication. I’m still hesitant about mailto: links being anywhere near me…
• Data stored w/ localStorage to hopefully minimize requests
• Open your JS console to watch the async functions make their requests
• URL params for testing other users and cache.
  Ex: http://rocktronica.github.com/?user=github&cache=false

Ok, quick recap:

• Data URIs allow for inline resource inclusion without additional HTTP requests. Among other things, this allows for writing content directly to the address bar, and it’s the way my tmpltr app exports stuff.
• HTML5 has a contentEditable attribute that can turn anything into an input.
• And somebody clever (@tabatkins, according to @paul_irish) took to combining the two to make “the world’s smallest text editor“:

  data:text/html,<pre contenteditable></pre>

I was pretty enamored by that and used a variant of it at work for awhile to jot down my notes during the day. Like all tinkerers, I couldn't leave well enough alone, and so here's my fancier but definitely-not-the-smallest-and-so-not-as-novel version:

Clickable:
data:text/html,<body id='b'><textarea spellcheck=%22false%22 id=%22t%22></textarea><script>var f, t=document.getElementById(%22t%22), b=document.body, v=t.value, c=parseInt(b.getAttribute(%22c%22)) || t.value.length;t.focus();document.title=t.value.split(%22\n%22)[0] || %22...%22;t.className=%22s%22;function updateUrl(){clearInterval(f);f=setTimeout(function(){if (v===t.value){return false;}t.className=%22%22;t.innerHTML=encodeURIComponent(t.value);var s=%22data:text/html,<body id='b'%22;if (!!t.selectionStart){s +=%22 c='%22 + t.selectionStart + %22'%22;}s +=%22>%22 + b.innerHTML;window.location.href=s;}, 500);}t.addEventListener(%22keyup%22, updateUrl);if (!!t.setSelectionRange){t.setSelectionRange(c,c);setTimeout(function(){t.setSelectionRange(c,c);}, 10);}</script><style>textarea{position: fixed;top: 0;left: 0;width: 100%;height: 100%;overflow: auto;margin: 0;padding: 10px;background: black;font: 14px/20px monospace;outline: none;border: none;box-sizing: border-box;cursor: wait;color: gray;}textarea.s{cursor: text;color: white;}</style><!--http://iamnotagoodartist.com/web/an-auto-updating-data-uri-text-editor -->

Breakdown

Mine uses a textarea instead of a contenteditable <pre>, since it's made to be fullscreen and thus doesn't need contenteditable's auto-adjustment to variably dimensioned content. (Actually, the one regret is that my text editor now won't use any of the HTML5 spec and so is not as trendy... Sniffle, sniffle.)

So we've got a fixed and fullscreen input. We'll use its first line (if it has one) as the document title and bind a debounced* function to its keyup event. When the function executes successfully, we write a new URL using the existing body's HTML, the input's encoded value, and its caret/selection position, and then we'll redirect the user to it, setting the caret position and repeating the process indefinitely.

* Debouncing is a method of rate limiting. It takes a time duration and waits that long after each firing to run, resetting and delaying execution if fired before the duration is up. Its more common sibling is throttling, which will run at most once per time duration while firing and will not reset.

Unordered, Non-Narrative Findings

• If the software and its data share the same limited storage mechanism, brevity must trump legacy support: no CSS3 vendor prefixes, not a lot of feature sniffing or graceful degradation, etc. All JS is vanilla and doesn't use external libraries.
• Like local files, Data URIs are prohibited from a number of things for security reasons; cookies, localStorage/sessionStorage, and any history manipulation are out the window. Thus, there's no saving beyond the URL and updates happen with old-fashioned redirects instead of the cooler pushState.
• I'm storing caret position as just a c attribute to save some bytes. There may be a better way to do it, and I'm not sure what the technical implications are for arbitrary attributes like that instead of, say, a data attribute.
• Dirty/clean save status is handled with a CSS class to gray out the text and use the wait cursor. May be overkill.
• textareas have both value and innerHTML. At init they are the same, but only value changes as the user interacts with it; no HTML is changed. Because we're using the body's innerHTML to rewrite the URL, we must set the input's innerHTML to its value, encodeURIComponented for safety.
• Nobody will call the cops if you don't close your body tag.

Still Could Use...

• Different browsers have different URL limits. Ideally, this would have some sort of reservoir meter.
• Code and markup is properly escaped, but trying to save anything with </textarea> will effectively close the input and bork all the text thereafter. It escapes me how to get around that at the moment...
• Safari takes a couple microseconds to focus an element and won't allow caret setting while it's unfocused, so there's some awkward and redundant setTimeout stuff in there to give it some time. I'd like for that to be less crummy.

Unavoidable Gotchas

• Data URIs aren't supported in IE. Tested successfully in Chrome, Firefox, Safari, and Opera.
• Undo and redo can't persist over redirect. (But, interestingly, you can use native back and forward to kind of view the text's history.)
• Browsers can interpret Data URIs, yes, but most software won't automatically turn them into links like traditional HTTP URLs. So copy-and-pasting into chats will always have to be prefaced with "Hey, copypaste this into a new tab, k?"

How is this useful?

Honestly? Probably only as an academic pursuit.

But try this: open it up and write something, copy the URL and paste it into another tab or browser. Your text persisted without a database, any external script, or proprietary Cloud gizmo. No legal order can cease it to exist, and you didn't even need an internet connection. I think that's pretty neat!

Font: Carton

“I want you to be so rich you can wear suits like those,” she says.

“I want to be so rich I never have to,” I respond.