I thought this was a pretty cool idea, and that it would be a fun project for a Raspberry Pi. I agreed with the people who thought using UPC barcodes would be better, since products already have them, so I went with a barcode scanner + online product database.

Here’s a summary of the features that I’ve added to my microwave:

• Re-designed touchpad
• Nicer sounds
• Clock is automatically updated from the internet
• Can be controlled with voice commands
• Can use a barcode scanner to look up cooking instructions from an online database
• There weren’t any online microwave cooking databases around, so I made one: http://microwavecookingdb.com
• The microwave has a web page so you can control it from your phone (why not), and set up cooking instructions for products
• Tweets after it’s finished cooking something (See https://twitter.com/rbmicrowave)

Demo Video

Using a Raspberry Pi to cook a Raspberry Pie

Here’s the recipe.

Keep reading below if you’re interested in electronics or software:

Hardware

I used a microwave with a touchpad, and discovered that the touchpad was a button matrix. I took photos of the touchpad and traced the wires, so that I could tell which pins corresponded to which buttons.

I initially wanted to put everything in a case outside the microwave, but I decided that it would be more challenging and fun to try and fit everything inside. Here’s all the PCB revisions, before I settled on a design that would fit neatly on top of the microwave’s original PCB.

I used shift registers and optocouplers to control the touchpad pins. To listen for touchpad presses, an output shift register scans one line at a time on the first touchpad layer, and an input shift register listens for connections to the second layer.

I unsoldered the touchpad connector from the original circuit board, and replaced it with a row of pin headers. I then used the original touchpad connector on my PCB, so that my circuit acts as a kind of proxy for button presses.

Here’s the final product after transferring toner, etching, drilling, and soldering. (I had to use the ribbon cables to save space.)

And here’s how it fits on top of the microwave controller:

When I peeled off the old touchpad overlay, it became wrinkled and ugly, so I thought I may as well have a go at redesigning the interface. My goal was to get rid of the features I don’t really use, and make the basic functions more convenient. The top two rows of buttons are now dedicated to “one touch” cooking times, for either “high” or “medium” power. You can also set the time and power manually.

You might have noticed that I started the project with the intention of using an Arduino Nano plugged into a Raspberry Pi USB port. This was because I was a) familiar with the Arduino, b) not familiar with the Raspberry Pi GPIO, and c) thought it would make testing and debugging a bit easier, since I could just plug the Arduino into my laptop.

However, it turns out that my Raspberry Pi had some issues with the arduino’s FTDI chip if the Raspberry Pi was turned on while the Arduino was plugged in. It wouldn’t recognize the Arduino until I unplugged it, and then plugged it back in again.

So I decided to make an Arduino Nano => Raspberry Pi GPIO adapter, and port my Arduino code to the Raspberry Pi GPIO using the WiringPi library.

The Raspberry Pi is powered by a USB hub, which is also plugged into the Raspberry Pi’s USB port. To power the hub, I wired up a power adapter to the microwave’s power source. There’s also a USB powered speaker, USB microphone, wifi adapter, and barcode scanner.

Microwave Software

All the software running on the Raspberry Pi is hosted at: https://github.com/ndbroadbent/raspberry_picrowave.

There are 4 main components:

Microwave Daemon

This runs the code that listens for touchpad button presses, and controls the microwave. It also accepts TCP connections so that other programs can send commands or request information about the microwave’s status.

Barcode Instructions

This program listens to the barcode scanner, and requests product information from the Microwave Cooking Database. It also runs the cooking programs.

Voice Control

I used PocketSphinx for voice recognition, which worked very well with my small corpus. I embedded Ruby in the pocketsphinx_contiunous C program, so that it would be easier to script voice commands and send commands to the microwave daemon. It turns out that the acoustics of my kitchen seem to mess up the recognition, so it won’t be used very often.

Sinatra App

There’s a simple sinatra web application that lets you control the microwave from your phone or computer. This may not be a big selling point. It uses a JavaScript EventSource to push updates to the browser, so you could have hundreds of users connected to your microwave at once.

If any barcodes are scanned that can’t be found on the Microwave Cooking Database, this webpage will display the unknown barcodes and provide a link to add the new product.

Microwave Cooking Database

I couldn’t find any existing websites with a database of microwave cooking instructions, so I made one.

If cooking instructions are posted for a 1000W microwave, you can request the instructions for a 700W microwave, and the cooking times will be automatically adjusted.

So if you’re also planning on making an internet connected microwave with a barcode scanner, please feel free to sign up and add some products.

Patents?

Nope, this is just a fun project. Microwaves with barcode scanners already exist, and most of these features are already patented.

Thanks for reading!

I’d be interested to hear if you do something similar, or make use of http://www.microwavecookingdb.com.

One extra feature for Ruby developers is support for backtrace lines like this:

app/models/post.rb:225:in `sharing_is_caring'

If you double-click that file, you’ll end up with the following selection: app/models/post.rb:225:in. The script will automatically strip the trailing :in, so you can just double-click instead of manually highlighting.

Requirements

• Ubuntu
• xclip (install with sudo apt-get install xclip)
• A text editor, such as Sublime Text 2.

Installation

• Download the open_selected_in_editor script to somewhere like ~/bin.

mkdir -p ~/bin
wget https://raw.github.com/ndbroadbent/dotfiles/master/bin/open_selected_in_editor -O ~/bin/open_selected_in_editor
chmod +x ~/bin/open_selected_in_editor

• Modify the script to use your preferred text editor

Set up current working directory support

Add the following line to your ~/.bashrc:

PROMPT_COMMAND+="pwd > ~/.cwd~;"

This means that every time you press return in the terminal, the script can use your current directory to determine an absolute path for a highlighted file. It’s not completely foolproof, but good enough for me.

Set up a keyboard shortcut in Ubuntu 12.04

• Go to System Settings –> Keyboard –> Shortcuts –> Custom Shortcuts
• Click the + to add a new shortcut with:
  • Name: Open selected in editor
  • Command: ~/bin/open_selected_in_editor
• Set the keyboard shortcut. I like Ctrl+Shift+X.

All done! Now you can highlight a filename in the terminal, press your keyboard shortcut, and open it in your editor without the need to copy & paste filenames. Please let me know if you need any help, but I’m sorry I don’t know how to do this in OS X or Windows.

After running a Rails generator, you’ll often need to edit the generated files in your text editor.

Rails 4 may soon have the ability to open generated files in your text editor if you pass the --editor option on the command line. You can follow my pull request for more details.

If you use the --editor option (or its -e alias), the generator will open all generated or copied files in your text editor. The default editor is your GUI_EDITOR or EDITOR environment variable, but you can set the editor manually with --editor=manual-code-editor.

Rails 3 isn’t accepting any new features, so here’s how you can use the --editor option for your Rails 3 apps:

Single Rails 3 app

To install the --editor option in a single Rails 3 app, run the following command from your app directory:

curl https://gist.github.com/raw/4342095/rails -o script/rails

This will update script/rails, and you can commit the change.

Globally for all Rails 3 apps

If you are developing a lot of different apps, it might be too much hassle to update all of them. Instead, you can download the custom rails script to your /bin directory, and add some shortcut functions to your .bashrc.

Download script:

sudo curl https://gist.github.com/raw/4342095/rails3_with_editor -o /bin/rails3_with_editor
sudo chmod +x /bin/rails3_with_editor

Add shortcut functions:

Add the following to your ~/.bashrc:

rge() { rails3_with_editor generate "$@" --editor; }
rgm() { rails3_with_editor generate migration "$@" --editor; }

Now you can run rgm to generate a migration from any Rails 3 app.

Could not find <gem> in any of the sources
Run `bundle install` to install missing gems.

This happens if you or someone else adds a gem to your Gemfile, or if a gem version is updated in Gemfile.lock, and you forget to run bundle install before running a Rails command.

Here’s a simple function that handles this automatically, called bundle_install_wrapper(). It first tries to execute the command you pass to it. However, if Bundler exits with status code 7 (GemNotFound), then it will run bundle install. Finally, it retries the original command.

bundle_install_wrapper() {
  # Run command
  eval "$@"
  if [ $? = 7 ]; then
    # If command crashes, try a bundle install
    echo -e "\033[1;31m'$@' failed with exit code 7."
    echo    "This probably means that your system is missing gems defined in your Gemfile."
    echo -e "Executing 'bundle install'...\033[0m"
    bundle install
    # If bundle install was successful, try running command again.
    if [ $? = 0 ]; then
      echo "'bundle install' was successful. Retrying '$@'..."
      eval "$@"
    fi
  fi
}

Usage

Drop the function in your ~/.bashrc, and add aliases for rails commands:

alias rs="bundle_install_wrapper rails server"
alias rc="bundle_install_wrapper rails console"
# etc.

If you want aliases that support any Rails application, you can use something like this:

# Run Rails commands on any version
rails_cmd(){
  # Rails 3
  if [ -e ./script/rails ]; then bundle_install_wrapper rails3_with_editor $@
  # Rails <= 2
  elif [ -e ./script/$1 ]; then bundle_install_wrapper ./script/$@
  # Rails 4
  elif [ -e ./config.ru ] && grep -q Rails config.ru; then bundle_install_wrapper rails $@
  else echo "== I don't think this is a Rails application!"
  fi
}
alias   rs="rails_cmd server"
alias  rsd="rails_cmd server -u"
alias   rc="rails_cmd console"
alias   rg="rails_cmd generate"

See the Ruby on Rails section in my .bashrc if you’re interested in more aliases, and please leave a comment if you have any tips to share.

If you’ve been using capistrano without the capistrano_colors gem, well, you’ve been missing out! Your logs will now be nicely formatted and colored by default, like this:

However, if you happen to be a big fan of black & white logs, you can just add disable_log_formatters to config/deploy.rb. See the Formatting Logs wiki page for more information about customizing the colors and styles.

Thanks to @stjernstrom for creating the capistrano_colors gem, and to @carsomyr for merging my pull request!

While I was working on scm_breeze and my dotfiles repo, I grew tired of having to type this command, so I aliased it to sbrc. But I knew I could do better, so I created an auto-reload script that reloads my ~/.bashrc if there are any changes to itself, or any of the files that it loads.

When you run it at the beginning of your .bashrc, it wraps the source and . commands with a function that builds an index of all the sourced files. At the end of your .bashrc, you need to call the finalize_auto_reload function, which:

• Removes the source and . overrides
• Sorts the sourced file index and removes duplicates
• Stores the mtime of the most recently modified source file in a variable
• Adds the auto_reload_bashrc function to your PROMPT_COMMAND.

Whenever you start a new line in your terminal, the auto_reload_bashrc function reloads your .bashrc if any of the sourced files have changed. Changes are detected by looking up the most recent modification time from all of the sourced files, and comparing that time with the previous value.

My .bashrc sources 28 files from my dotfiles, scm_breeze, and RVM. Running the auto_reload_bashrc function to check for changes only takes 11 ms.

If you make a lot of changes to your .bashrc or .zsh, you can check out my auto-reloading script here: https://github.com/ndbroadbent/dotfiles/blob/master/bashrc/auto_reload.sh

(My laptop’s hostname is also represented by a symbol.)

For the ls output, it was a bit tricky to re-justify the username and group columns after substituting my username. I decided to do it in ruby, and then played some ruby golf:

o=STDIN.read;re=/^(([^ ]* +){2})(([^ ]* +){3})/;u,g,s=o.lines.map{|l|l[re,3]}.compact.map(&:split).transpose.map{|a|a.map(&:size).max+1};puts o.lines.map{|l|l.sub(re){|m|"%s%-#{u}s %-#{g}s%#{s}s "%[$1,*$3.split]}}

This little script parses the modified output of ls -lhv, calculates the max length of the user/group/size columns, and then pads those columns with the correct number of spaces.

My final ls command looks like this:

ls -lhv --group-directories-first | sed \"s/$USER/\$(/bin/cat $HOME/.user_sym)/g\" | rejustify_ls_columns

(where rejustify_ls_columns is a function wrapping the ruby script above.)

I’m using the whenever gem to create cron tasks that:

• Update all my git repos from their remotes
• Satisfy all of my Gemfile’s dependencies
• Cache rake and capistrano commands for tab completion
• Fetch Travis CI build statuses to show in my terminal
• Maintain an index of my git repos so I can quickly switch between projects, while keeping them organized

For all of these tasks, I’m using the git_index function provided by my SCM Breeze project. It creates an index of all your git projects by recursively scanning your code directory, and then lets you quickly jump to projects, or run batch commands for each of your repos. See my SCM Breeze blog post for more info about the repository index.

Updating Git Repos

Every 30 minutes I run a task that updates all of the local branches on all of my git repos. It does this as safely as possible:

• Doesn’t do anything if there are any changed files in the working directory
• Doesn’t do anything unless remote and merge branches are explicitly configured for that branch
• Doesn’t do anything if it cannot ‘fast-forward’ merge a branch (i.e. the current commit is not a parent of the latest commit in the remote repo)

Basically, this means that it will leave you alone if you are working on a feature, or if you’ve committed something that you haven’t pushed yet.

Otherwise, it will bring your branches up-to-date and send a desktop notification:

Installing Gem dependencies

I have a task that runs every hour to ensure that all of my gem dependencies are installed. If someone adds a new gem dependency to your project, it’s great to have that automatically installed when the repo is automatically updated.

I’m using the git_index function to run a script called bundle_check_or_install for each of my git repos. It also sends desktop notifications on update or failure, and doesn’t do anything if the gems are already up-to-date.

If bundle install fails for any reason, it will touch a file at '.skip_bundle_auto_install~ (and exclude that file from git by adding it to .git/info/exclude). Any future attempts to auto-update your gems will abort with the notification that “Previous bundle install failed”. This notification can be disabled if .skip_bundle_auto_install~ contains the string “SILENT”. I do this when I stop caring about old projects, but don’t want to delete or archive them.

Caching Rake and Capistrano commands for tab completion

rake -T and cap -T can take a long time to run, so I run a task every hour to cache the available tasks for all of my projects, and I use these cached tasks to provide tab completion. The tasks in saved to files like .cached_rake_tasks~ and .cached_cap_tasks~. Here’s how I set up the Bash tab completion.

Fetching Travis CI Build Status

I’ve written about this before in my Travis CI Status in Shell Prompt post. Every 30 minutes I run a task to fetch build statuses for all the repos that contain a .travis.yml file. The status is saved in a hidden file called .travis_status~, and displayed in my prompt like this:

Updating Git Repo Index

All of the previous tasks depend on the git repo index being up-to-date. It only takes a few seconds to scan through my code directories, so I run this task every minute.

This index lets me keep my code organized in different folders, while also letting me jump to different projects by name:

If you want to set this up for yourself, you’ll need to check out my SCM Breeze project. The schedule.rb that defines these tasks lives in my dotfiles repo, and you can find the scripts I use in the /bin directory.

Post a comment if you have any automation ideas to share!

Creating a Google Group is easy (just go to https://groups.google.com and follow the prompts), but the slightly tricky part is sending invites to everyone who’s interested in your project. I decided to start by inviting all the contributors to the Errbit codebase (there’s 73 contributors at the time of writing this post.)

You can get a list of contributor emails by running git log --format='%ae' | sort -u from your git repo. However, Google Groups only lets you invite 10 emails at a time, so here’s a Bash/Zsh script that will print all of your contributor emails as CSV, in groups of 10:

emails=( $(git log --format='%ae' | sort -u) )
total_groups=$(( ${#emails[@]} / 10 ))

for ((i=0; i <= $total_groups; i++)); do
  echo "Group $((i + 1)):"
  echo "-------------------------------------------------------"
  grouped_emails=( ${emails[@]:$(( $i * 10 )):10} )
  printf "%s, " "${grouped_emails[@]}" | cut -d "," -f 1-${#grouped_emails[@]}
  echo
done

After pasting this script into your terminal, you can copy and paste each batch of emails into the Enter email addresses of people to invite textarea. But be careful to write and save your invite message in your text editor, because if you write it on the page you won’t be able to get it back after sending the first batch of invites.

It will still be quite a tedious process since you’ll need to enter a captcha for each batch, but hopefully this script will save you some time.

(NOTE: You must have installed Skype, and logged in at least once.)

bash < <(curl -s https://raw.github.com/gist/2181122/skype-libnotify.sh)

This downloads and executes the script from this gist: https://gist.github.com/2181122

It fetches the skype configuration from here, which is part of my dotfiles repo.

In my case, I was updating a plugin for our Thoughtworks Mingle instance, but the update wasn’t hugely important. Many of our staff rely on Mingle for their work, and restarting it takes it offline for a few minutes.

So I used the at command to schedule the restart to happen at midnight, after everyone had gone home:

$ echo "/etc/init.d/mingle restart" | at -m 00:00
job 6 at 2012-02-26 00:00

Use atq or at -l to see the list of pending jobs:

$ atq
6   2012-02-26 00:00 a root

Use at -c <job id> to view the script that will be run:

$ at -c 6

#!/bin/sh
# atrun uid=0 gid=0
# mail     root 1
umask 22
HOSTNAME=...
<lots of environment variables set here>

/etc/init.d/mingle restart

To delete a scheduled task, run at -d <job id>:

$ at -d 6
$ atq
(no output)

I’ve updated the build status checking script, because updating all branches was taking too long (over 20 minutes.) Now it performs frequent updates for the current branch, and only periodic updates for all branches.

Travis CI is a distributed continuous integration service for the open source community, and it can be used with any of your public projects on GitHub. You’ve probably seen some ‘build status’ badges like this:

Wouldn’t it be cool if you could see that build status in your shell prompt whenever you are working on a project?

Here’s what my shell prompt looks like now:

This shows the build status for the current branch.

You will need to cache the build status, since looking it up takes a few seconds.

You should use my fork of mislav’s travis-ci script, which can check the build status of a project. Make sure ~/bin is in your PATH, and if you are using RVM, make sure you are using your default ruby.

Run the following to install it:

mkdir -p ~/bin/
curl -sL https://raw.github.com/gist/1708408/travis.rb > ~/bin/travis-ci \
  && chmod +x ~/bin/travis-ci

gem install hub | tail -2
ruby -e 'require "json"' 2>/dev/null || gem install json

Next, we need to update the cached status. The following code is included as part of my SCM Breeze project, but feel free to save the update_travis_ci_status script at the bottom of this post [1] to /usr/bin/update_travis_ci_status.

We will also need a way to run this update task every few minutes, across all of our local git repos. We only want to frequently update the status for the currently checked out branch, and periodically update the status for all branches.

The SCM Breeze project also maintains an index of your git repositories, which gives you the ability to run batch commands via the git_index function. So the build status update can be easily set up as a cron task:

*/5 * * * * /bin/bash -c '. $HOME/.bashrc && git_index --rebuild && git_index --batch-cmd update_travis_ci_status'
*/45 * * * * /bin/bash -c '. $HOME/.bashrc && git_index --rebuild && export UPDATE_ALL_BRANCHES=true && git_index --batch-cmd update_travis_ci_status'

Alternatively, you could save the following script to /usr/bin/update_all_travis_ci_statuses.

#!/bin/bash
# (Replace `$HOME/code` with the location of your projects)
for f in find "$HOME/code" -maxdepth 4 -name .travis.yml; do
  (builtin cd "$(dirname $f)" && update_travis_ci_status)
done

… and use the following cron task:

*/5 * * * * /bin/bash -c '. $HOME/.bashrc && /usr/bin/update_all_travis_ci_statuses'
*/45 * * * * /bin/bash -c '. $HOME/.bashrc && export UPDATE_ALL_BRANCHES=true && /usr/bin/update_all_travis_ci_statuses'

(you need to source your .bashrc if your default ruby comes from RVM)

Finally, you need a way to display the cached status in your prompt.

Here are the functions I use to return a colored pass / fail / running symbol:

# Returns the Travis CI status for a github project
parse_travis_status() {
  local branch="$1"
  if [ -z "$branch" ]; then branch="master"; fi

  local stat_file=$(find_in_cwd_or_parent ".travis_status~")
  if [ -e "$stat_file" ]; then
    case "$(grep -m 1 "^$branch " "$stat_file")" in
    *passed)  echo "\[\e[01;32m\]✔ ";; # green
    *failed)  echo "\[\e[01;31m\]✘ ";; # red
    *running) echo "\[\e[01;33m\]⁇ ";; # yellow
    esac
  fi
}

# Test whether file exists in current or parent directories
find_in_cwd_or_parent() {
  local slashes=${PWD//[^\/]/}; local directory=$PWD;
  for (( n=${#slashes}; n>0; --n )); do
    test -e $directory/$1 && echo "$directory/$1" && return 0
    directory=$directory/..
  done
  return 1
}

(it also works if you are in a project’s sub-directory.)

Finally, add $(parse_travis_status "$current_branch") somewhere in your $PS1. You should set the $current_branch variable to the current git branch, but it defaults to the master branch if you leave it blank.

You may like to have a look at the prompt section of my dotfiles, to see how I do it.

Enjoy! Please let me know if you have any questions, or need some help.

[1] update_travis_ci_status script:

#!/bin/bash
if [ -e ".travis.yml" ]; then
  if type ruby > /dev/null 2>&1 && type travis-ci > /dev/null 2>&1; then
    local stat_file=".travis_status~"
    local tmp_stat_file="$stat_file"".tmp"

    # Either update all branches, or only current branch
    if [ "$UPDATE_ALL_BRANCHES" = "true" ]; then
      local all_branches=$(\git branch -a)
      # All branches on origin remote that have local copies
      local branches=$(comm -12 <(echo "$all_branches" | \
                                  sed "s/ *remotes\/origin\///;tm;d;:m;/^HEAD/d;" | sort) \
                                <(echo "$all_branches" | \
                                  sed "/ *remotes\//d;s/^[\* ]*//" | sort))
      # Create a new, blank temp file
      echo -n > "$tmp_stat_file"
    else
      # Only current branch
      local branches="$(\git branch 2> /dev/null | sed "s/^\* \([^ ]*\)/\1/;tm;d;:m")"
      # Copy current file to temp file
      touch "$stat_file"
      cp -f "$stat_file" "$tmp_stat_file"
    fi

    for branch in $branches; do
      local travis_output=$(travis-ci "$branch" 2>&1)
      local status=""
      case "$travis_output" in
      *built\ OK*)    status="passed";;
      *failed*)       status="failed";;
      *in\ progress*) status="running";;
      esac

      # If branch has a build status
      if [ -n "$status" ]; then
        if grep -q "^$branch" "$tmp_stat_file"; then
          # Replace branch's build status
          sed -e "s/^$branch .*/$branch $status/" -i "$tmp_stat_file"
        else
          # Append new line for branch
          echo "$branch $status" >> "$tmp_stat_file"
        fi
      fi
    done

    # Replace current stat file with finished update
    mv -f "$tmp_stat_file" "$stat_file"
    # Ignore status file from git repo
    if ! ([ -e .git/info/exclude ] && grep -q "$stat_file" .git/info/exclude); then
      echo "$stat_file" >> .git/info/exclude
    fi
  fi
fi

Find out more about Travis CI here.

We’ve been working on some powerful features for Fat Free CRM, such as dynamic custom fields, and we wanted to make sure that they work across all of our supported databases. So here’s how I set up our Travis CI build matrix to test multiple databases, with some help from the Travis docs:

.travis.yml

We add the databases to our build matrix by setting ENV variables. Add the following lines to your .travis.yml:

env:
  - DB=mysql
  - DB=postgres
  - DB=sqlite  

Database configuration

We package multiple example database configurations for each of our supported databases, like this:

• config/database.mysql.yml
• config/database.postgres.yml
• config/database.sqlite.yml

We also have a rake task that is a prequisite for the spec task, and this sets up the example configuration files for Travis.

It copies the database.yml template specified by our DB variable, using postgres as the default.

FileUtils.cp "config/database.#{ENV['DB'] || 'postgres'}.yml", 'config/database.yml'

Gemfile.ci

I created a new Gemfile for CI. It simply tells bundler to use the gem specified by our DB variable, prevents any other database gems from being loaded, and then loads the ‘real’ Gemfile.

Here’s the contents of Gemfile.ci:

case ENV['DB']
when "mysql"; gem "mysql2", "0.3.10"
when "sqlite"; gem "sqlite3" 
when "postgres"; gem "pg", ">= 0.9.0"
end

def gem(*args)
  # Override 'gem' method to block any other database gems in the 'real' Gemfile
  super unless %w(pg sqlite3 mysql2).include?(args.first)
end

# Eval Gemfile
eval(IO.read(File.join(File.dirname(__FILE__), 'Gemfile')), binding) 

That’s all there is to it.

This is a slightly unrelated topic, but I had a lot of trouble getting our new Gemfile.ci to work properly. After a serious headache, I figured out that we hadn’t updated config/boot.rb to the latest version after our upgrade. This new boot.rb had a very subtle difference, and contained the following line:

ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)

instead of:

ENV['BUNDLE_GEMFILE'] = gemfile

Notice the ||=, which meant that the BUNDLE_GEMFILE variable could actually have an effect when it was set by Travis.

You might have found this post if you are googling for Could not find multi_json-1.0.3 in any of the sources, which is the symptom that I was experiencing (due to an updated gem and an outdated Gemfile.lock). In that case, you may need to update your config/boot.rb to the latest version from Rails.

The following post describes a part of my SCM Breeze project. If you haven’t seen it already, take a look at my blog post that describes what it can do.

Here were my goals when I set out to find a solution:

• I wanted a design directory for each of my projects
• I didn’t want the design directory to be checked in to the git repository
• The design directory needed to be synchronized across all of my machines

I decided that I would need to store all of my design files in one place so that they could be easily synchronized, and I would create symlinks from each project to the root design directory.

The simplest way for me to synchronize files was via my Dropbox account. However, if you work with a larger team, you could set up a shared design directory on one of your servers and synchronize it with rsync.

Either way, here’s how you can effectively manage your design assets for git projects:

1) Install SCM Breeze

This gives you the design() function, as well as a bunch of other features that you can read about here.

To install, run:

git clone git://github.com/ndbroadbent/scm_breeze.git ~/.scm_breeze
~/.scm_breeze/install.sh
source ~/.bashrc   # or source ~/.zshrc

2) Create and configure a root design directory

I created my root design directory at ~/Dropbox/Design.

After you’ve created your root design directory, edit ~/.scmbrc and set root_design_dir to the directory you just created. You can also configure the design directory that’s created in each of your projects (default: design_assets), as well as the subdirectories you would like to use. The default base subdirectories are: Images, Backgrounds, Logos, Icons, Mockups, and Screenshots.

After you have changed these settings, remember to run source ~/.bashrc or source ~/.zshrc.

3) Initialize design directories for your projects

To set up the design directories and symlinks, go to a project’s directory and run:

design init

If your root directory is ~/Dropbox/Design, directories will be created at ~/Dropbox/Design/projects/my_project/Backgrounds, ~/Dropbox/Design/projects/my_project/Icons, etc.

It will then symlink the project from your root design directory into your project’s design directory, so you end up with:

• my_project/design_assets –> ~/Dropbox/Design/projects/my_project

It also adds this directory to .git/info/exclude so that git ignores it.

Here’s the awesome part: If you use the SCM Breeze git repository index, you can run the following batch command to set up these directories for all of your git repos at once:

git_index --batch-cmd design init

If you want to remove any empty design directories, run:

design trim

And if you want to remove all of a project’s design directories, even if they contain files:

design rm

4) Link existing design directories into your projects

If you’ve set up your design directories on one machine, you’ll want them to be synchronized across all of your other development machines.

Just run the following command on your other machines after following steps 1 and 2:

design link

This uses your git index (from SCM Breeze) to figure out where to create the symlinks. If you don’t use the git index, the same outcome could be achieved by running ‘design init’ for each of the projects.

Enjoy!

Please leave a comment on this blog post if you have any questions. If you find a bug, or it doesn’t work quite right on your operating system, please raise an issue on Github.

Shameless Dropbox Referral

If you don’t already use Dropbox, click here to sign up! It’s an awesome service! And if you sign up via that referral link, you’ll be giving me a little extra free space :)

Restrictions like this (not being able to change your default browser) are one of the many reasons why I wouldn’t buy another iPhone if it couldn’t be jailbroken. It also seems strange that ‘Hacker News’ readers don’t appear to be very excited about ‘hacking’ the incredible device in their pockets.

We don’t need to ask developers to support Chrome when we can just change the default browser ourselves:

You can find the “Browser Changer” package on Cydia.

Here’s 9 other reasons why a jailbroken iPhone is better than any other mobile device:

Grooveshark

The Grooveshark iPhone app was removed from the App Store, so you can only install it on a jailbroken iPhone through Cydia.

The ‘Grooveshark Anywhere’ plan is required if you want to download unlimited albums and songs to play offline, but it’s well worth the $9 per month. It’s definitely a replacement for iTunes, so it’s no wonder that Apple feels threatened.

Note: I also tried Spotify for a week when it was released to New Zealand, but I found that Grooveshark has a much bigger music collection.

SSH

Having SSH access to your phone opens up a lot of possibilities. For example, I use capistrano to deploy iPhone apps and Cydia packages while I’m developing them. I can also SFTP into the iPhone’s filesystem, and use Ubuntu’s file browser to copy and paste files.

VLC media player

Plays anything you can transfer to your iPhone. Another great app rejected from the App Store.

Mobile Terminal

It’s pretty neat to have a terminal on your phone, even if I don’t use it very often. You never know when you might need to restart or rollback a remote server:

SBSettings

This is an incredibly useful shortcuts menu, displayed by swiping the status bar:

The AutoLock control is really handy when using the Maps application. I use Maps as the GPS for my car, and I don’t want the screen to turn off while I’m driving.

MyWi – 3G tethering

I bought the MyWi package while using a 3GS. It’s pretty expensive at $19.99, but it was a lifesaver when I was living without DSL for a few weeks. I’m still using it after getting a 4S, since iOS 5’s ‘personal hotspot’ feature was a bit flaky. MyWi is rock-solid, and can display a small icon instead of taking over the entire status bar like the iOS hotspot.

5 columns for icons

This is just my personal preference, but I like having 5 icons in my dock and home screen.

Compiling and installing any open source iPhone apps

No $99 developer license required. One example is the Last.FM app, which is open source, but not available in NZ or HK iTunes stores. Here’s a decent list of some other open source iPhone apps.

Script anything

Finally, and perhaps most importantly, it’s just awesome to be able to script the phone to do whatever I want. For example, I can make the iPhone change the wallpaper every 30 minutes, show my prepaid balance in the status bar, or scroll up and down a page when it tilts.

Conclusion

Jailbroken iPhones FTW.

Please leave a comment if you have any tips to share!

SCM Breeze is a set of shell scripts (for bash and zsh) that enhance your interaction with tools such as git. It integrates with your shell to give you numbered file shortcuts, a repository index with tab completion, and a community driven collection of useful SCM functions.

Disclaimer: git is currently the only supported SCM. I’ve kept the project’s name open because it won’t be difficult to port it for other SCMs.

File Shortcuts

SCM Breeze makes it really easy to work with changed files, and groups of changed files. Whenever you view your SCM status, each modified path is stored in a numbered environment variable. You can configure the variable prefix, which is ‘e’ by default.

git_status_shortcuts:

These numbers (or ranges of numbers) can be used with any SCM or system command.

For example, if ga was your alias for git add, instead of typing something like:

$ ga assets/git_breeze/config* assets/git_breeze/install.sh

You can type this instead:

$ ga $e2 $e3 $e11

But SCM Breeze aliases ga to the git_add_shorcuts function, which is smart enough to expand integers and ranges, so all you need to type is:

$ ga 2 3 11

And if you want to add all unstaged changes (files 1 to 10):

$ ga 1-10

(Note that ga will also remove deleted files, unlike the standard git add command. This behaviour can be turned off if you don’t like it.)

You can also diff, reset or checkout a file by typing:

$ gd 3
$ grs 4
$ gco 5

You can use these shortcuts with system commands by passing your command through exec_git_expand_args (default alias is ‘ge’):

$ echo $e4
# => assets/git_breeze/git_breeze.sh
$ ge echo 4
# => assets/git_breeze/git_breeze.sh
$ ge echo 1-3
# expands to echo $e1 $e2 $e3
# => _shared.sh assets/git_breeze/config.example.sh assets/git_breeze/config.sh

Keyboard bindings (disabled by default)

My most common git commands are git status, git add and git commit, so I wanted these to be as streamlined as possible. One way of speeding up commonly used commands is by binding them to keyboard shortcuts.

Keyboard shortcuts are turned off by default, but here are the default key bindings if you enable them:

• CTRL+SPACE => git_status_shortcuts – show git status with file shortcuts
• CTRL+x c => git_add_and_commit – add given files (if any), then commit staged changes
• CTRL+x SPACE => git_commit_all – commit everything

The commit shortcuts use the git_commit_prompt function, which gives a simple prompt like this:

(When using bash, this commit prompt gives you access to your bash history via the arrow keys.)

And if you really want to speed up your workflow, you can type this:

$ 2 3 <CTRL+x c>

This sends the HOME key, followed by git_add_and_commit:

Repository Index

The second feature is a repository index for all of your projects and submodules. This gives you super-fast switching between your project directories, with tab completion, and it can even tab-complete down to project subdirectories. This means that you can keep your projects organized in subfolders, but switch between them as easily as if they were all in one folder.

It’s similar to autojump, but it doesn’t need to ‘learn’ anything, and it can do SCM-specific stuff like:

• Running a command for all of your repos (useful if you ever need to update a lot of remote URLs)
• Auto-updating a repo when you switch to it and it hasn’t been updated for at least 5 hours.

The default alias for git_index is ’s’, which could stand for ‘source’ or ‘switch’ :)

You will first need to configure your repository directory, and then build the index:

$ s --rebuild
# => == Scanning /home/ndbroadbent/src for git repos & submodules...
# => ===== Indexed 64 repos in /home/ndbroadbent/src/.git_index

Then you’ll be able to switch between your projects, or show the list of indexed repos:

To switch to a project directory, you don’t need to type the full project name. For example, to switch to the errbit project, you could type any of the following:

$ s errbit
$ s err
$ s rbit

Or if you wanted to go straight to a subdirectory within errbit:

$ s err<TAB>
$ s errbit/<TAB>
# => app/       autotest/  config/    db/    ...
$ s errbit/conf<TAB>
$ s errbit/config/
# => cd ~/src/rails/errbit/config

Anything else?

If you have any awesome SCM scripts lurking in your .bashrc or .zshrc, please feel free to send me a pull request. It would be cool to make this project into an oh-my-zsh for SCMs.

Installation

git clone git://github.com/ndbroadbent/scm_breeze.git ~/.scm_breeze
~/.scm_breeze/install.sh
source ~/.bashrc   # or source ~/.zshrc

(The install script simply appends the following line to your .bashrc or .zshrc):

[ -s "$HOME/.scm_breeze/scm_breeze.sh" ] && . "$HOME/.scm_breeze/scm_breeze.sh"

Configuration

SCM Breeze is configured via automatically installed ~/.*.scmbrc files. To change git configuration, edit ~/.git.scmbrc.

Note: After changing any settings, you will need to run source ~/.bashrc (or source ~/.zshrc)

I know we grow attached to the aliases we use every day, so I’ve made them completely customizable. Just change any aliases in ~/.git.scmbrc. You can also change or remove any keyboard shortcuts.

Each feature is modular, so you are free to ignore the parts you don’t want to use. Just comment out the relevant line in ~/.scm_breeze/scm_breeze.sh.

Updating

Run update_scm_breeze. This will update SCM Breeze from Github, and will create or patch your ~/.*.scmbrc files if any new settings are added.

Contributing

SCM Breeze lives on Github at https://github.com/ndbroadbent/scm_breeze

Please feel free to fork and send pull requests, especially if you would like to build these features for Mercurial, SVN, etc.

Enjoy!

So here’s a wrapper function that makes it less of a hassle to integrate the clipboard with the command line.

• It handles input via pipe or parameters.
• It automatically uses the contents of a file if you pass it a valid filename.
• It prints an excerpt of what has been copied, truncated to 80 characters.

Examples

• Pipe anything to the clipboard

$ tail -n 100 /var/log/apache2/error.log | cb
# => Copied to clipboard: [Sun Oct 02 08:02:08 2011] [notice] Apache/2.2.17 (Ubuntu) configured -- resumin...

• Copy the contents of a file to the clipboard

$ cbf ~/.ssh/id_rsa.pub
# => Copied to clipboard: ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAnwaNIuOhZzUeR6/xEEudXt3zEh91dawhkkKx8p/+4Bw9...

• Type straight into the clipboard

$ cb This is some unquoted text.
# => Copied to clipboard: This is some unquoted text.

No options, no man pages.

It also comes with a handy cb_ssh alias that copies your SSH public key to the clipboard, for when you are setting up your new BitBucket account with unlimited, free private git repositories! I’m not affiliated with Atlassian, I just think they’re awesome.

So if you think this looks handy, you can add the following to your ~/.bashrc:

# A shortcut function that simplifies usage of xclip.
# - Accepts input from either stdin (pipe), or params.
# ------------------------------------------------
cb() {
  local _scs_col="\e[0;32m"; local _wrn_col='\e[1;31m'; local _trn_col='\e[0;33m'
  # Check that xclip is installed.
  if ! type xclip > /dev/null 2>&1; then
    echo -e "$_wrn_col""You must have the 'xclip' program installed.\e[0m"
  # Check user is not root (root doesn't have access to user xorg server)
  elif [[ "$USER" == "root" ]]; then
    echo -e "$_wrn_col""Must be regular user (not root) to copy a file to the clipboard.\e[0m"
  else
    # If no tty, data should be available on stdin
    if ! [[ "$( tty )" == /dev/* ]]; then
      input="$(< /dev/stdin)"
    # Else, fetch input from params
    else
      input="$*"
    fi
    if [ -z "$input" ]; then  # If no input, print usage message.
      echo "Copies a string to the clipboard."
      echo "Usage: cb <string>"
      echo "       echo <string> | cb"
    else
      # Copy input to clipboard
      echo -n "$input" | xclip -selection c
      # Truncate text for status
      if [ ${#input} -gt 80 ]; then input="$(echo $input | cut -c1-80)$_trn_col...\e[0m"; fi
      # Print status.
      echo -e "$_scs_col""Copied to clipboard:\e[0m $input"
    fi
  fi
}
# Aliases / functions leveraging the cb() function
# ------------------------------------------------
# Copy contents of a file
function cbf() { cat "$1" | cb; }  
# Copy SSH public key
alias cbssh="cbf ~/.ssh/id_rsa.pub"  
# Copy current working directory
alias cbwd="pwd | cb"  
# Copy most recent command in bash history
alias cbhs="cat $HISTFILE | tail -n 1 | cb"  

bundle install haml is totally different from bundle update haml.

What bundle install haml does:

1. Installs all of your gems into a ‘haml’ folder. (creates the folder if it doesn’t exist)
2. Saves the  ‘haml’ path in .bundle/config, so that it becomes your default gem folder for every bundle command you run in the future.

If you made this mistake and want to reset everything back to normal, just run:

rm -rf {gem} .bundle/config

Then, to update your gem, you should run:

bundle update {gem}

At the end of every line, there was an invisible ‘reset’ color code, and this meant that ‘sed “s/string$/$replace”’ was no longer finding ‘string$’.

Here is an example of how to use sed when your string contains color codes:

# Need to strip the color character from the end of the line, otherwise
# EOL '$' doesn't work. This gave me a headache for long time.
# The echo ~> regex is time-consuming, so perform a simple search first.
if [[ $line == *$search* ]]; then
    line=$(echo $line | sed -r "s:$search(\x1B\[m)?$:$replace:g")
fi

You might also find this page useful: http://www.commandlinefu.com/commands/view/3584/remove-color-codes-special-characters-with-sed