What about those developers, like myself, who rarely (if ever) find themselves in the same room as their coworkers? Enter wemux by Matt Furden, the tmux tool that makes it simple for multiple users to connect to the same tmux session so you can see the same thing.

The only requirement, according to the README, is tmux >= 1.6. Installation is simple, with the preferred method being Homebrew:

>> brew install https://github.com/downloads/zolrath/wemux/wemux.rb

After installation, you — the host — would start a new wemux server:

>> wemux start

At this time, anyone else — the clients — could connect with any of the following three commands:

• wemux mirror – attach to the server in read-only mode.
• wemux pair – attach to the server in pair mode, where both the client and the host can control the terminal.
• wemux rogue – attach to the server in rogue mode, where the client and host can work independently of eachother.

There are plenty of other features, from listing users to running multiple wemux servers at once. Once you get the hang of it, pairing while working remotely becomes much simpler than screen sharing on Skype!

You can find out everything you need to know in the README or discuss this post on HackerNews.

The post Multi-user tmux made easy with wemux appeared first on The Changelog.

brew install the_silver_searcher

If you aren’t on a Mac, or using homebrew, there are other installation instructions on the README. Using it is very straightforward, especially if you have used ack (or grep) in the past:

ag stringtofind ~/code

I know what you’re thinking, what is ag? Well, Ag is the chemical symbol for silver, and it’s a lot easier to type than the_silver_server, so Geoff went with it! There are a number of features that make The Silver Searcher worth giving a try:

• Speed: 3-5x faster than ack
• It honors .gitignore, .hgignore, and .agignore
• ag is 33% shorter than ack (admittedly this is silly, but you can’t argue the facts!)

Discuss this on HackerNews or view the repo on GitHub.

The post Searching, improved with The Silver Searcher appeared first on The Changelog.

Two years ago Felipe Coury submitted a pull request to add ghost-ssh to manipulate ~/.ssh/config files. If it weren’t for Google pointing me to this pull request, I would have never known ghost-ssh existed. The readme says nothing about it!

This is what Felipe had to say when he submitted his patch:

I had a need to manipulate ~/.ssh/config file the same way I can manipulate my hosts entries, so I made this change.

Not sure if it will be useful for the upstream project, but be welcome to merge if you like.

An intro to ghost-ssh

Just like with ghost on the command line, ghost-ssh has basic list, add, and delete options, as well as an import operation to import files.

To save you some time, here’s the contents of ghost-ssh --help:

$ ghost-ssh --help
USAGE: ghost-ssh add <host> <hostname> [--user=<user>] [--port=<port>]
       ghost-ssh modify <host> <hostname> [--user=<user>] [--port=<port>]
       ghost-ssh delete <host>
       ghost-ssh list
       ghost-ssh empty
       ghost-ssh export
       ghost-ssh import <file>

An example of adding a new entry to your ssh/config might look something like this:

$ ghost-ssh add tclprod xxxxxx.gridserver.com --user=tcladmin
  [Adding] tclprod -> xxxxxx.gridserver.com

You can confirm the entry was added to ssh/config by running the ghost-ssh list command:

$ghost-ssh list                                             
Listing 1 configs(s):
  tclprod -> tcladmin@xxxxxx.gridserver.com:22

Now that I have this new entry in place, I can easily ssh into the server by running ssh tclprod and boom goes the dynamite!

Checkout the source for Ghost on GitHub for install and usage details.

Discuss on Hacker News if you’d like.

The post Ghost means never having to touch ssh/config again (either) appeared first on The Changelog.

• nodefront compile – Compiles Jade and Stylus files to HTML and CSS. Can compile upon modification, serve files on localhost, and even automatically refresh the browser/styles when files are changed.

• nodefront fetch – Automatically fetches CSS/JS libraries for use in your project. Provides an interactive mode to add new libraries.

• nodefront insert – Inserts CSS/JS libraries directly into your HTML or Jade files.

• nodefront minify – Minifies CSS and JS files. Can also optimize JPG and PNG images.

Karthik has put together a twenty minute screencast for a full demonstration.

Check out the project web site or source on GitHub for more.

The post Nodefront – Node.js-powered rapid front-end development utility appeared first on The Changelog.

@thechangelog You should checkout @asciiio by @sickill – similar service, less dependencies :-)

— Łukasz Korecki (@lukaszkorecki) April 2, 2012

Powered by Python, ascii.io from Marcin Kulik is fully open source, both client and server. You can install the client with a simple shell script:

$ curl -sL get.ascii.io | bash

Once installed, use the asciiio command line interface to record your session, optionally logging in with GitHub or Twitter to store your recordings under your profile at ascii.io.

Check out the source on GitHub for info on usage and how to contribute.

Bonus: Nyan Cat!

The post ascii.io – Python-powered terminal recording and sharing appeared first on The Changelog.

With noexec, Josh has created a small script that will walk up your directory structure until it can find a Gemfile. If the executable you’re running is in that Gemfile, it will use it instead of Bundle.setup.

Simply install the gem:

gem install noexec

… and be sure to export the following environment variable in your shell profile:

RUBYOPT="-r`noexec`"

Check the source on GitHub for more.

The post noexec – Run Ruby scripts without bundle exec appeared first on The Changelog.

http PATCH api.example.com/person/1 X-API-Token:123 name=John email=john@example.org

PATCH /person/1 HTTP/1.1
User-Agent: HTTPie/0.1
X-API-Token: 123
Content-Type: application/json; charset=utf-8

{"name": "John", "email": "john@example.org"}

I appreciate the colored terminal output:

Source on GitHub.

The post httpie – Python-powered HTTP CLI for humans appeared first on The Changelog.

The DSL aims to be a readable, convenience wrapper around OptionParser:

#!/usr/bin/env ruby

require 'optparse'
require 'methadone'

include Methadone::Main

main do |name,password|
  name # => guaranteed to be non-nil
  password # => nil if user omitted on command line
  options[:switch] # => true if user used --switch or -s
  options[:s]      # => ALSO true if user used --switch or -s
  options[:f]      # => value of FILE if used on command-line
  options[:flag]   # => ALSO value of FILE if used on command-line

  ...
end

description "One line summary of your awesome app"

on("--[no-]switch","-s","Some switch")
on("-f FILE","--flag","Some flag")
on("-x FOO") do |foo|
  # something more complex; this is exactly OptionParser opts.on 
end

arg :name
arg :password, :optional

go!

Since Methadone also scaffolds out your Cucumber features, you can test your CLI via Aruba:

Feature: My bootstrapped app kinda works
  In order to get going on coding my awesome app
  I want to have aruba and cucumber setup
  So I don't have to do it myself

  Scenario: App just runs
    When I run `newgem --help`
    Then the exit status should be 0
    And the output should contain:
    """
    Usage: newgem [options]
    """

Check out the README for advanced usage or the roadmap to see how you might contribute.

The post Methadone – Build better Ruby-based CLI’s with logging and Cucumber support appeared first on The Changelog.

from cement2.core import foundation
app = foundation.lay_cement('helloworld')
app.setup()
app.run()
print('Hello World')

With the single call to lay_cement, this Python script is a full-fledged CLI complete with usage and help information:

$ python helloworld.py --help
usage: helloworld.py [-h] [--debug] [--quiet]

optional arguments:
  -h, --help  show this help message and exit
  --debug     toggle debug output
  --quiet     suppress all output

I especially like how Cement separates interfaces and handlers, allowing for swappable implementations of features based on command line arguments. There is also a robust plugin architecture for those that want to extend it. Be sure and check out the Portland branch for the source as Cement2 is still under active development.

The post Cement2, Python CLI framework nears beta appeared first on The Changelog.

• a source folder
• a demo folder and nice looking HTML page with your assets wired up
• default license
• Rakefile for managing releases

The bundled Rakefile includes a release task that lets you easily version and deploy new versions of your script. Check out the GitHub repo to fork and contribute.

The post JazzLibs – Ruby CLI to rollout and manage JavaScript libraries appeared first on The Changelog.

Capt is aimed at developers building single page, stand alone applications as well as server-backed applications using Node.js, bundling the following projects and languages:

Languages

• Coffeescript
• JavaScript
• SCSS
• LESS

Testing frameworks

• Qunit
• Jasmine [planned]

Libraries

• jQuery
• Backbone.js
• Underscore.js
• json2.js

Installation

You can grab Capt from npm

npm install capt

To check your installation and see usage help, just run capt in your terminal:

Usage:

capt new projectname 
  - create a new project

capt server
  - serve the current project on port 3000

capt watch
  - watch the current project and recompile as needed

There’s also generators to create Backbone models and controllers:

capt generate model <model name>

capt generate controller <controller name>

Capt is still in alpha but is under active development. Got ideas? Why not contribute?

[Source on GitHub] [Web site]

The post capt: Command line tool for creating Backbone.js apps appeared first on The Changelog.

Installation and usage

Install JSON Pipe via pip

pip install jsonpipe

Now we can pipe data into jsonpipe to see a breakdown of the structure of the document:

$ echo '[{"a": [{"b": {"c": ["foo"]}}]}]' | jsonpipe
/   []
/0  {}
/0/a        []
/0/a/0      {}
/0/a/0/b    {}
/0/a/0/b/c  []
/0/a/0/b/c/0        "foo"

How about inspecting an NPM package?

curl https://github.com/jashkenas/coffee-script/raw/master/package.json | jsonpipe

/ {}
/name "coffee-script"
/description  "Unfancy JavaScript"
/keywords []
/keywords/0 "javascript"
/keywords/1 "language"
/keywords/2 "coffeescript"
/keywords/3 "compiler"
/author "Jeremy Ashkenas"
/version  "1.1.0-pre"
/licenses []
/licenses/0 {}
/licenses/0/type  "MIT"
/licenses/0/url "http://github.com/jashkenas/coffee-script/raw/master/LICENSE"
/engines  {}
/engines/node ">=0.2.5"
/directories  {}
/directories/lib  "./lib"
/main "./lib/coffee-script"
/bin  {}
/bin/coffee "./bin/coffee"
/bin/cake "./bin/cake"
/homepage "http://coffeescript.org"
/repository {}
/repository/type  "git"
/repository/url "git://github.com/jashkenas/coffee-script.git"

Since the output is regular STDOUT, JSON Pipe is piping hot:

curl https://github.com/jashkenas/coffee-script/raw/master/package.json | jsonpipe | grep "homepage"

/homepage   "http://coffeescript.org"

JSON Pipe will show you the key/value structure of your JSON documents faster than you can say XPath.

[Source on GitHub]

The post jsonpipe: Convert JSON to a UNIX-friendly line-based format using Python appeared first on The Changelog.

Ethan Schoonover has taken a different approach with Solarized, a theme that comes with support for a number of tools out of the box including:

• Vim
• Mutt e-mail client
• Xresources / Xdefaults
• iTerm2
• OS X Terminal.app
• Adobe Photoshop Palette (inc. Lab values)
• Apple Color Picker Palette
• GIMP Palette

Never before has so much design gone into a color theme. Ethan supports both light and dark variations to support selective contrast and other features

There’s even a Sass implementation:

$base03:    #002b36;
$base02:    #073642;
$base01:    #586e75;
$base00:    #657b83;
$base0:     #839496;
$base1:     #93a1a1;
$base2:     #eee8d5;
$base3:     #fdf6e3;
$yellow:    #b58900;
$orange:    #cb4b16;
$red:       #d30102;
$magenta:   #d33682;
$violet:    #6c71c4;
$blue:      #268bd2;
$cyan:      #2aa198;
$green:     #859900;
@mixin rebase($rebase03,$rebase02,$rebase01,$rebase00,$rebase0,$rebase1,$rebase2,$rebase3) 
{
    background-color:$rebase03;
    color:$rebase0;
    * { color:$rebase0; }
    h1,h2,h3,h4,h5,h6 { color:$rebase1; border-color: $rebase0; }
    a, a:active, a:visited { color: $rebase1; }
}
@mixin accentize($accent) {
    a, a:active, a:visited, code.url { color: $accent; }
    h1,h2,h3,h4,h5,h6 {color:$accent}
}
/* light is default mode, so pair with general html definition */
html, .light { @include rebase($base3,$base2,$base1,$base0,$base00,$base01,$base02,$base03)}
.dark  { @include rebase($base03,$base02,$base01,$base00,$base0,$base1,$base2,$base3)}
html * {
    color-profile: sRGB;
    rendering-intent: auto;
}

We didn’t see TextMate support. Perhaps you could fork the project and contribute.

[Source on GitHub]

The post solarized: Light and dark precision color scheme for terminal apps, editors appeared first on The Changelog.

Installation and usage

To get started, install Earthquake via RubyGems:

gem install earthquake

The gem installs a command line application, invoked via earthquake. The first time you run the application, you’ll be redirected to Twitter in a new browser window to authorize the application and provide a PIN to enter into the Earthquake prompt to complete the OAuth setup:

~ » earthquake                                                                        ~  
1) open: http://api.twitter.com/oauth/authorize?oauth_token=UF5HD9XH8pvAQtrhvQwpO0iZmyvLgJ8sGhEPdhLA
2) Enter the PIN: 

Once authenticated, you’ll get a nifty lightning bolt prompt (⚡) from which you can tweet, search, even eval Ruby:

# tweet
⚡ Hello World!

# Search
⚡ :search #ruby

# Eval
⚡ :eval Time.now

As Mathias Meyer was nice to point out, you’ll want to type :exit not exit to leave the application.

Be sure and check the README for advanced usage and color customization.

Earthquake for Node.js?

Intrigued by my exit tweet, Changelog alum Tim Caswell wants to rebuild Earthquake in Node.js and offered a fine start in under thirty seconds.

[Source on GitHub]

The post earthquake: Twitter terminal client with streaming API support appeared first on The Changelog.

Commander

TJ Holowaychuk’s latest projects seem to have a Node.js flavor, but TJ has released a ton of Ruby projects, too. Commander is a robust API for creating Ruby command line applications. Commander sits atop OptionParser, HighLine and other libraries you probably already use. It also supports formatters as well as text-to-speech and Growl support on MacOS. It even has support for nice looking terminal tables via TJ’s terminal-table gem:

+----------+-------+----+--------+-----------------------+
| Terminal | Table | Is | Wicked | Awesome               |
+----------+-------+----+--------+-----------------------+
|          |       |    |        | get it while its hot! |
+----------+-------+----+--------+-----------------------+

Eyeballs.js

Eyeballs from Paul Campbell is a lightweight JavaScript MVC framework that sits on top of jQuery or Prototype that provides features such as hash-based URL routing, data models, and local storage. A humorous feature of Eyeballs is the syntax and the ‘eep eep’ function:

// declare a model
o_O('Post', function(post){
  post.validates_presence_of('title')
})

You gotta love that. o_O

Screeninator

Inspired by Arthur Chiu’s wildly popular terminitor, Jon Druse’s Screeninator orchestrates your screen sessions.

# ~/.screeninator/project_name.yml
# you can make as many tabs as you wish...

escape: ``
project_name: Screeninator
project_root: ~/code/rails_project
tabs:
  - shell: git pull
  - database: rails db
  - console: rails c
  - logs: 
    - cd logs
    - tail -f development.log
  - ssh: ssh me@myhost

Scalatra

Scalatra is a Scala port of everyone’s favorite Ruby microframework.

package org.scalatra

class ScalatraExample extends ScalatraServlet {

  // send a text/html content type back each time
  before {
    contentType = "text/html"
  }

  // parse matching requests, saving things prefixed with ':' as params
  get("/date/:year/:month/:day") {
    <ul>
      <li>Year: {params("year")}</li>
      <li>Month: {params("month")}</li>
      <li>Day: {params("day")}</li>
    </ul>
  }

  // produce a simple HTML form
  get("/form") {
    <form action='/post' method='POST'>
      Post something: <input name='submission' type='text'/>
      <input type='submit'/>
    </form>
  }

  ...

Fabric.js

One of the cool things about SVG is the DOM API. Fabric.js from Juriy Zaytsev provides an interactive object model on top of the HTML5 <canvas> element.

<canvas id="canvas" width="300" height="300"></canvas>  
...

var canvas = new fabric.Element('canvas');

var rect = new fabric.Rect({
  top: 100,
  left: 100,
  width: 60,
  height: 70,
  fill: 'red'
});

canvas.add(rect);

Be sure and check out the extensive Fabric.js demo and sandbox.

The post WatchWednesday for 20101006 appeared first on The Changelog.

Install the gem

gem install optitron

A quick example

@parser = Optitron.new {
  opt 'verbose', "Be very loud"
  cmd "install", "This installs things" do
    arg "file", "The file to install"
  end
  cmd "show", "This shows things" do
    arg "first", "The first thing to show"
    arg "second", "The second optional thing to show", :required => false
  end
  cmd "kill", "This kills things" do
    opt "pids", "A list of pids to kill", :type => :array
    opt "pid", "A pid to kill", :type => :numeric
    opt "names", "Some sort of hash", :type => :hash
  end
  cmd "join", "This joins things" do
    arg "thing", "Stuff to join", :type => :greedy
  end
}

Then you can print those options with @parser.help:

Commands

show [first] <second>          # This shows things
install [file]                 # This installs things
kill                           # This kills things
  -p/--pids=[ARRAY]            # A list of pids to kill
  -P/--pid=[NUMERIC]           # A pid to kill
  -n/--names=[HASH]            # Some sort of hash
join [thing1 thing2 ...]       # This joins things

Global options

-v/--verbose                   # Be very loud

Let’s see how Optitron parses inbound arguments

response = @parser.parse(%w(-v install file))
response.command
=> "install"
response.args
=> ["file"]
response.params
=> {"verbose" => true}

With four patch releases today, this gem is moving fast but one to keep an eye on.

[Source on GitHub]

The post Optitron: Easily add option and command parsing to your Ruby CLI appeared first on The Changelog.

YAML front-matter isn’t a special part of your brain, rather it’s YAML formatted meta-data at the top of a text file, a pattern made popular by Webby, Jekyll, Nanoc, and other static-ish publishing tools:

---
title: The Tumblr Gem
state: queue
format: markdown
tags: Ruby, Tumblr, Weary
slug: tumblr-rb
---


You can also give it a URL:

  $ tumblr http://mwunsch.github.com/tumblr/tumblr.1.html

That will create a _Link_ post on Tumblr pointing to the `tumblr` manpage.

Another cool thing about tumblr-rb is how Mark has employed Chris Wanstrath’s new gem-man (Changelog article forthcoming) to create awesome looking man pages for the gem.

Tumblr is about removing the friction from blogging workflow. If you spend any time in the terminal, tumblr-rb takes it even farther.

[Source on GitHub] [Marks’ Tumblog]

The post tumblr-rb – Post to tumblr from the command line appeared first on The Changelog.

To install:

gem install ghost

And then from the command line:

$ ghost add mydevsite.local
  [Adding] mydevsite.local -> 127.0.0.1

$ ghost add staging-server.local 67.207.136.164
  [Adding] staging-server.local -> 67.207.136.164

$ ghost list
Listing 2 host(s):
  mydevsite.local      -> 127.0.0.1
  staging-server.local -> 67.207.136.164

$ ghost delete mydevsite.local
  [Deleting] mydevsite.local

Aside from basic list, add, and delete options, Ghost provides powerful import and delete_matching operations to import files or delete entries based on pattern matching.

Check out the source on GitHub.

UPDATE: We covered ghost-ssh, a hidden feature of ghost which lets you manipulate your ~/.ssh/config file as well.

The post Ghost means never having to touch /etc/hosts again appeared first on The Changelog.

twitter_contacts = Prism.find 'http://twitter.com/markwunsch', :hcard
me = twitter_contacts.first
me.fn
#=> "Mark Wunsch"
me.n.family_name
#=> "Wunsch"
me.url
#=> "http://markwunsch.com/"
File.open('mark.vcf','w') {|f| f.write me.to_vcard }
## Add me to your address book!

Or if the command line is your bag:

$: prism --hcard http://markwunsch.com > ~/Desktop/me.vcf

or using STDIN and cURL:

$: curl http://markwunsch.com | prism --hcard > ~/Desktop/me.vcf

Prism also includes a DSL for parsing your own POSH formats:

class Navigation < Prism::POSH::Base
    search {|document| document.css('ul#navigation') }
    # Search a Nokogiri document for nodes of a certain type

    validate {|node| node.matches?('ul#navigation') }
    # Validate that a node is the right element we want

    has_many :items do
        search {|doc| doc.css('li') }
    end
    # has_many and has_one define properties, which themselves inherit from
    # Prism::POSH::Base, so you can do :has_one, :has_many, :search, :extract, etc.
end

[Source on GitHub] [Docs] [Mark Wunsch on Twitter]

The post Prism – command line and Ruby library parser for Microformats appeared first on The Changelog.

Feature: exit statuses

  In order to specify expected exit statuses
  As a developer using Cucumber
  I want to use the "the exit status should be" step

  Scenario: exit status of 0
    When I run "ruby -h"
    Then the exit status should be 0

  Scenario: non-zero exit status
    When I run "ruby -e 'exit 56'"
    Then the exit status should be 56

Aruba provides the exit status step:

Then /^the exit status should be (\d+)$/ do |exit_status|
  @last_exit_status.should == exit_status.to_i
end

To use Aruba just install the gem

sudo gem install aruba

and then require it in your env.rb or any file under features/support

require 'aruba'

Check out the source on GitHub or the Cucumber homepage for more info.

The post aruba – Cucumber steps for testing your command line apps appeared first on The Changelog.

What they probably didn’t know is that there’s a Ruby library & CLI tool for accessing the back-end of Things Open Sourced on GitHub.

There are number of reasons why you’d use a command line version of Things, including:

1. You’re a geek and you like using Terminal and the command line
2. You don’t need to keep “Things” running all the time
3. You can access your todo’s remotely via SSH (even from a Windows or Linux box)
4. Use GeekTool to keep your todo’s on the desktop

Example from the README:

things = Things.new # will use Things' default database location. 
# things = Things.new(:database => '/path/to/Database.xml')

tasks = things.today.map do |task|
  tags    = "(#{task.tags.join(' ')})" if task.tags?
  project = "[#{task.parent}]" if task.parent?
  [task.bullet, task.title, tags, project].compact.join(" ")
end

puts tasks.compact.sort.join("n")

[Source on GitHub] [README]

The post things-rb: Ruby lib & CLI for Things (mac) appeared first on The Changelog.