hg branch - display the branch you're currently on.

hg branches - display all branches for the current repository.

hg checkout <branchname> - checkout the specified branch. Also if you want to disregard any local changes before switching use the --clean option.

hg status - show all files that have changes pending.

hg diff - output the pending changes of all files.

hg commit -m <commit message> - commit pending changes to your current branch.

hg pull - get the most recent changes done to the repo, from the remote server.

hg update - this will attempt to merge all the changes from the remote pull, to your local file system.

hg push - push all your changes up to the remote server.

Extra Commands

hg serve - by default, will start a server on localhost:8000, which will give you a neat little UI in your browser to view your mercurial logs, branch graphs, tags, bookmarks, and branches. It also has a help section to get more detailed info on hg commands, and whatnot.

hg graph -r <commit revision> - when you want to pull in a specific change revision to your branch without pulling anything else (similar to git cherry-pick). Also depending on your Mercurial version, you can also use hg transplant more info

hg shelve and hg unshelve - set your pending changes aside temporarily and restore them at a later time. more info

I made an action with the same name as the filter, and had it output to logger.error.

class HomeController < ApplicationController
  after_action :after_action
  before_action :before_action
  append_after_action :append_after_action
  append_before_action :append_before_action
  prepend_after_action :prepend_after_action
  prepend_before_action :prepend_before_action
  around_action :around_action
  prepend_around_action :prepend_around_action
  append_around_action :append_around_action

  def after_action
    logger.error("after_action #{Time.now}")
  end

  def append_after_action
    logger.error("append_after_action #{Time.now}")
  end

  def append_around_action
    logger.error("append_around_action #{Time.now}")
    yield
  end

  def append_before_action
    logger.error("append_before_action #{Time.now}")
  end

  def around_action
    logger.error("around_action #{Time.now}")
    yield
  end

  def before_action
    logger.error("before_action #{Time.now}")
  end

  def prepend_after_action
    logger.error("prepend_after_action #{Time.now}")
  end

  def prepend_around_action
    logger.error("prepend_around_action #{Time.now}")
    yield
  end

  def prepend_before_action
    logger.error("prepend_before_action #{Time.now}")
  end

end

The output looked like this:

  Started GET "/home/index" for 127.0.0.1 at 2014-03-12 15:41:02 -0700
  Processing by HomeController#index as HTML

prepend_around_action 2014-03-12 15:41:02 -0700
prepend_before_action 2014-03-12 15:41:02 -0700
before_action 2014-03-12 15:41:02 -0700
append_before_action 2014-03-12 15:41:02 -0700
around_action 2014-03-12 15:41:02 -0700
append_around_action 2014-03-12 15:41:02 -0700

  Rendered layouts/application.html.erb (0.5ms)
  Rendered home/index.html.erb (0.5ms)

append_after_action 2014-03-12 15:41:02 -0700
after_action 2014-03-12 15:41:02 -0700
prepend_after_action 2014-03-12 15:41:02 -0700

  Completed 200 OK in 12ms (Views: 9.8ms | ActiveRecord: 0.0ms)

Well balls, I needed something that ran after all my code but ran before I rendered the view, and none of the filters seemed to do that.

I found a type of answer on StackOverflow.

It called for injecting your own render action, and setting up a before_action filter that would set an instance variable to true for the action(s) you want to have your filter run on.

before_action :set_global_modal, only: [:index]

def render(*args)
  build_global_modal if @do_global
  super
end  

def set_global_modal
  @do_global = true
end

It worked good for my situation. The only gotcha was that the monkeypatched render method will run for all of your renders in that controller. So just be sure to only run it in the controller you need it for and not have it in your ApplicationController, or every action in your entire program is going get routed through there.

If somebody has a better way to do this, let me know - cause this does seem kinda broken.

[1] hollandaise_party »  blank_string = String.new
=> ""
[2] hollandaise_party »  price = blank_string.to_d
=> 0.0
[3] hollandaise_party »  price.present?
=> true
[4] hollandaise_party »  price = ''
=> ""
[5] hollandaise_party »  price.present?
=> false

Although I'm not sure what I expected to happen - when trying to figure out why

validates :price, presence: true

was failing when I did not put a value into the input box on my form, turns out the above example is why.

I try not to rely on front end form validations all that much, and build out ActiveRecord validators first. And during the inital stages of testing, I couldn't figure out why that particular validation was failing when I didn't put anything in the input boxes.

Looking into further (I'm bad at source browsing) it looks to be doing something similar to Ruby's to_f method (even though I can't confirm it in the Rails/Rails repo).
If there is not a valid number at the start of str, 0.0 is returned.

So now we know if a blank string is passed to price.to_d method we're going to get 0.0. Well we could just do a check to see if it's blank? price.to_d if price.present? which would technically work. But let's say a user passed in text to our input boxes, instead of an Integer. At that point, the previous example is going to fail.

[6] hollandaise_party »  price = "loltext"
=> "loltext"
[7] hollandaise_party »  price.present?
=> true
[8] hollandaise_party »  price.to_d
=> 0.0

Balls.

There were a few ideas floating around on StackOverflow on how to deal with this - most people opted for regex. However, a more clever solution which I think works better than regex was this:

def is_a_number?(value)
  true if Float(value) rescue false
end

Which works for just about nearly any value you pass to it.

[9] hollandaise_party »  Float('-1000.00')
=> -1000.0
[10] hollandaise_party »  Float('1000')
=> 1000.0

The only thing I found an issue with was if a comma was included in the value.

[11] hollandaise_party »  Float('1,000.00')
ArgumentError: invalid value for Float(): "1,000.00"
from (pry):11:in `Float'

Easy enough solution for that, just .tr (source) the string and remove the comma, then pass that number to the Float(value). The whole method that I ended up using looks like this.

def is_a_number?(value)
  number = value.tr(',','')
  true if Float(number) rescue false
end

Now! Back to our validations! Should look something like this.

price.to_d if is_a_number?(price)

Shazam.
If there is a better way to do this let me know!

Using this error_hash as our example response:
error_hash = {'LOGINFAILBOAT' => 'Yo Your Login/Password Failed'}

With JSON, you can pass that to your response block and works just fine; try to respond with XML and no bueno. However Nokogiri let's you make it work, by passing the key of your hash as the xml element name.

When I hit my conditions to throw an error, I have it call the following method with the type and message, which is mostly a generic respond_to; with the exception of the XML response.

def return_error_response(error_type, message)
  error_response = { error_type => message }

  respond_to do |format|
    format.json { render json: error_response }
    format.xml  { render xml: build_xml_error_message(error_response) }
  end
end

And if it's an XML it gets sent to this method.

def build_xml_error_message(error_hash)
  error_attr = error_hash.keys.first
  error_valu = error_hash[error_attr]

  xml_error_message = Nokogiri::XML::Builder.new do |xml|
    xml.send(error_attr.to_sym, error_valu)
  end

  return xml_error_message

end

Pretty simple, but pretty simple was all I needed.

Fluid: This let's you take any URL and turn it into it's own .app file. It's free, but paying the $5 USD price tag allows you to have your apps have their own cookie storage. (I have Facebook/Twitter/Gmail setup to use Fluid)

Alfred: Assign a global hotkey that'll bring up a prompt to let you type out nearly any command you can think of - use it instead of using your mouse.

Flux: Changes your monitor during sunrise/sunset to the white point you select to make your eyes hate you less.

TotalSpaces: Let's you do all the things you wanted to be able to do with desktop spaces. Being able to assign applications to open up in specific spaces is almost worth the price alone.

iStumbler: See all the wireless access points around you.

Dash: Sometimes you don't have internet and you can't remeber the difference between days_ago and days_since

RSS Notifier: Cool RSS feed notifier that sits in your menu bar. (exportable copy of the feeds i follow)

With that said, I wanted to list what the configs are incase anybody wants to use them. Most of these are default settings, so feel free to adjust as needed.

nginx version: nginx/1.1.19
NGINX Configs

Node.js: npm -v 1.3.11
Ghost: config.js , Init.d Script