Jason Meridth

“Bad Interpreter: No Medium” error when running Ruby from Git Bash

Jason Meridth — Tue, 06 Oct 2009 14:50:00 GMT

I opened my Windows VM last night for the first time in months to finally work on a .NET project from Github. When I found out I needed the rspec gem installed (I'm normally a shoulda guy), I decided to see what gems I had installed first:

gem list

and got the following error:

$ gem list
sh.exe": /c/Ruby/bin/gem: D:/Users/Luis/projects/oss/oci/installer2-trunk/ruby/bin/ruby.exe: bad interpreter: no medium

Umm..... D:/Users/Luis? After some googling I found this article on StackOverflow that directed me to this blog. It pretty much states that the shebang line (#!) at the top of my Ruby One-Click installer file had changed/been corrupted, I don't know. I changed the line to point to my ruby exe (#!C:\Ruby\bin\ruby.exe) and my gem commands started working again.

Moving servers

Jason Meridth — Sat, 03 Oct 2009 03:32:00 GMT

To our readers,

We wanted to give you all a heads-up that we will be moving servers tomorrow evening, October 3rd, 2009. We plan to turn off all comments at 8 PM CST. The migration will begin at 9 PM CST. We do not have an estimate on the time that the move will take. We ask for your patience and look forward to being back to normal standing some time Sunday, October 4, 2009.

Again, we thank you for your patience.

git instaweb

Jason Meridth — Sun, 27 Sep 2009 00:53:00 GMT

I was reading "Pro Git" by Scott Chacon and was on the section about "git instaweb". This is where you can run gitweb, a cgi script that comes with git, locally or on a server. I have successfully gotten gitweb up for my personal git repos on my remote server. I use it all the time. I was curious if I could get it working locally, for friends who prefer a visual tool to see their git logs, commits, etc. I cd into a local repo (you have to cd into the .git folder of the app to get the desired view):

cd /code/app/.git

and run the instaweb command (note: I'm on a macbook pro that already has ruby installed, hence my choice of using webrick instead of the default lighttpd):

git instaweb -d webrick --start

I tried the command without the "--start" command and it kept trying to seek a browser. I tried "-b firefox", "-b Firefox", "-b /Application/Firefox.app/MacOS/firefox-bin", etc and they all failed. I found the "--start" suggestion on StackOverflow.com Once I ran this command, I could see the git log, commits, diffs, etc in gitweb for my local changes. What this will do is run the daemon on port 1234 of localhost. If you open your browser of choice and go to http://localhost:1234 then you will see gitweb for the git repository you ran the command in. The catch: you will have to stop the process manually. On my macbook, I ran the following command:

kill -9 `ps -aux | grep webrick | grep -v grep | awk '{print $2}'`

This will pass the id of the local process running webrick to "kill -9" and kill the process. ("grep -v grep" excludes the grep command you just ran from the processes returned in the ps query) Note: I personally use "git log --graph", gitk, gitx, or other tools for this, usually. Just thought it was a good addition to my git toolset.

Using gsub to wrap substring

Jason Meridth — Thu, 10 Sep 2009 19:56:47 GMT

Over my lunch today I finally had an opportunity to use something I learned yesterday reading Dan Croak's "gsub with a block" post on the Thoughtbot blog.

I use the twitter gem and just display my last status on my personal homepage at JasonMeridth.com. I didn't want to hand out my username and password so all I do is encapsulate the twitter piece in a module called TwitterHelper and put it into my app/helpers/ folder in my Rails application:

require 'twitter'
require 'pp'

module TwitterHelper  
  def latest_twitter_status(user_id='armmer')
    begin
      status = Twitter.user(user_id).status['text']
      status ||= ''
      status = status.gsub(/http:\/\/(.+?)\s/) do |url|
        " <a href='#{url}' target='_blank'>#{url}</a> "
      end
    rescue Exception => e
      logger.info("Twitter Helper Exception: " + e)
      status = ""
    end
  end
end

and then in my view I just call:

latest_twitter_status

The important part of code to look at is:

status = status.gsub(/(http:\/\/.*)/) do |url|
  " <a href='#{url}' target='_blank'>#{url}</a> "
end

This code will wrap any strings that start with http:// with an html href.

"git commit -a" and "git add"

Jason Meridth — Thu, 10 Sep 2009 17:07:00 GMT

I've heard or read too many git blog posts/pod casts state that if you create a new file in your local Git repo and you want to shorten the steps on getting it added to the local repository, all you have to do is:

git commit -am "my commit message"

This is _not_ true. If the file has never been added to the repo prior, then you still have to:

git add <file_name>

Why?

The "git commit -a" command is a shortcut to a two-step process. After you modify a file that is already known by the repo, you still have to tell the repo, "Hey! I want to add this to the staged files and eventually commit it to you." That is done by issuing the "git add" command. "git commit -a" is staging the file and committing it in one step.

If you create a new file, edit it, and issue the "git commit -a" command, you will see something like:

~ > mkdir test
~ > cd test
~/test > git initInitialized empty Git repository in /Users/jasonmeridth/test/.git/
~/test(master) > touch test
~/test(master) > git commit -am "initial commit"
# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       test
nothing added to commit but untracked files present (use "git add" to track)

The "nothing added to commit but untracked files present" is the key comment. Git even suggests using "git add" to track the file. See, it's user friendly. Just be aware.

Git local pre-commit hook

Jason Meridth — Thu, 10 Sep 2009 16:47:21 GMT

I've personally added a pre-commit hook to my local git repos. It's like a personal CI before I push back to origin/master. I run my tests locally anyway before committing and pushing, so I thought I would automate it.

I open the .git/hooks/pre-commit file in my local repo (i.e, full path is something like /Users/jasonmeridth/code/rails/myapp/.git/hooks/pre-commit) and put the following:

#!/bin/sh
rake db:migrate
rake db:test:prepare
rake

For non-rails developers, this will run any database migrations on my _development database, then ensure the _test database has the same schema, and then runs the tests.

Git hooks are not made executable by default, except on Windows because it doesn't understand the unix permissions. On my Mac, I have to issue the following command (from the app root):

chmod +x .git/hooks/pre-commit

This makes the pre-commit hook executable and Git will run it before every commit to this repo. If this process returns a non-zero value (failure), then the commit does _not_ happen. I'll be shown the failing tests and I can fix them and try to re-commit.

Git Post-receive hook with integrity post call

Jason Meridth — Fri, 17 Jul 2009 05:01:00 GMT

Using the following code:

This git post-receive hook script queries the latest commit, gets the revision changes, and then passes that payload (via json) to a net/https POST call. I setup our Integrity CI server with a self-signed certificate and HTTP basic authentication.

The Net::HTTP::Post.new instantiation group handles populating the basic authentication information and putting the payload into the form data of the request. The Net::HTTP.new group handles telling the request that it will be via SSL (443) and to not verify the SSL certificate (since I'm using a self-signed certificate; otherwise, I'd get a warning and kill my automation process)

The other important part is the "if pid = fork". The ruby fork command allows code to happen in the background, in the case the POST call, and therefore make the call synchronous. Otherwise, when the developers commit their code to the repository, they will have to wait for the build to finish before their prompt will be returned to them. fork will return zero (0) if it fails to create the background process.

I'm still checking whether the zombie process warning in the rdoc (for the fork command) is a problem. I'll update this if it is.

The last line is notification for the user so they know what's going on. Always good to keep the user in the loop. :)

Git For Windows Developers – Git Series – Part 3

Jason Meridth — Mon, 08 Jun 2009 02:45:00 GMT

Git For Windows Developers - Git Series - Part 1

Git For Windows Developers - Git Series - Part 2

Git For Windows Developers - Git Series - Part 3

THE .GIT FOLDER

Note: The SHA1s and tags in this post are unique to my system. The examples with SHA1s will not work on your system if you try the commands verbatim. The commands that use tags will work if you name your tags the same.

When you run “git init” in a directory locally or “git clone…” to bring an existing git repository down locally, that folder would now have a subdirectory called .git. This folder is the “soul” of git. If I run “ls –al” on my /c/code/console_app/.git folder I see the following folder structure:

Notice the “(GIT_DIR!)” text to the right on my console prompt. Msysgit is helping me by reminding me what folder I’m in. Also notice that I have a bunch of files and five folders (hooks, info, logs, objects and refs). I’m going to explain each directory then each file.

hooks

Consists of files that you can populate with scripts that will execute during certain times in the Git event model. These files are simply samples of what event hooks are available (hence the file extension of .sample). I’ve created post-receive hooks for continuous integration (CI) events in the past. Here is a previous post I wrote on setting up a post-receive hook to work with a Hudson CI server that has a self-signed certificate and uses HTTP basic authentication.

info

Consists of an exclude file that is the same as the .gitignore file but is not including in the repository itself and therefore is not versioned.

logs

Consists of a file, HEAD, and a subdirectory, refs, which has the history of the interactions with branches, both local and remote. The local branches (.git/logs/refs/heads/…) show commands like “git commit”, “git rebase”, “git reset”, etc. The remote branches (.git/logs/refs/remotes/…) are usually “git fetch”, “git pull” or “git push”

When I run “cat HEAD” I see all the commits I’ve issued from both my local master and local user_prompt branch.

GIT REFLOG

This file seems to just be a list of commits that I’ve made on all the branches I’ve used (even on the user_prompt branch which does not exist any longer). A better way to view this is via the “git reflog” command:

This command “is a mechanism to record when the tip of branches are updated. This command is to manage the information recorded in it”. (git-reflog) Any action I perform inside Git, when data is committed to the local repository, it is logged here to the reflog, aka the .git/logs/HEAD file. I have heard of Git users being able to recover commits after they reset the HEAD back a few commits. I have not personally tried this.

objects

Consists of all your objects (duh!). What are the objects? That’s a little ambiguous. It looks like a bunch of two character alpha-numeric folders, plus info and pack folders. In Git, objects are blobs, trees, commits, and tags. What are the two characters? They are the first two characters of an objects SHA1. Then the files in those folders are named with the remaining 38 characters. (i.e., 9a438f1e971835a3ad724eb408a68fae45d7470a would translate to .git/objects/9a/438f1e971835a3ad724eb408a68fae45d7470a)

BLOB

A blob is generally a file.

(http://book.git-scm.com/assets/images/figure/object-blob.png)

Consists of the binary content that is stored in the blob. No filename. Really? Yep. Git does not track files, it tracks content. So if you have two files with the same content but different names (shame on you for violating “Don’t Repeat Yourself (DRY)”) they will most likely point at the same blob object. “The object is totally independent of its location in the directory tree…”. This is usually handled by tree objects. “…and renaming a file does not change the object that the file is associated with” (http://book.git-scm.com/1_the_git_object_model.html)

When I issue the “git show 0e0fdc6” command:

where 0e0fdc6 is the SHA1 of the solution file on my initial commit, I see the files contents. “git show” is a way to view information about Git objects (blobs, commits, trees, tags).

TREE

A tree usually represents a directory or sub-directory, containing a list of other trees and blobs.

(http://book.git-scm.com/assets/images/figure/object-tree.png)

Consists of the type, SHA1 and filename of blobs and sub-trees. When I run the “git ls-tree 97107ec“ command:

with 97107ec being the SHA1 of the tree that my initial commit points to (shown in commit section below). If I issue a “git show 97107ec” on this tree SHA1:

I see the names of the contents, but not the types or SHA1s.

COMMIT

A commit is a pointer to the SHA1 of a tree.

(http://book.git-scm.com/assets/images/figure/object-commit.png)

Consists of the SHA1 of the tree it’s pointing at, the SHA1 of the parent commit, if not the initial commit, and the names of the author and committer. Huh? There’s a difference between the author and the committer. Imagine you write a patch for an open source project. When you tell the owner of the project to pull from your repository, you are the author, but they would the person committing it to the primary repository, the committer. If I issue the “git show –s --pretty=raw 1731c38“ command, where 1731c38 is the SHA1 of my “initial commit” commit:

I see the tree SHA1 that the commit points to, the author and the committer, who happen to both be me. If I just issue a regular “git show 1731c83”:

I actually see the diffs for all changes in the commit. Since this was the initial commit SHA1, I see lots of plus signs (+) in the diffs.

TAG

A tag is a pointer to the SHA1 of a Git object.

(http://book.git-scm.com/assets/images/figure/object-tag.png)

Consists of an object SHA1, the type of object the SHA1 represents and the name of the person who issued the tag, the tagger. I issue the “git tag v0.1 –m ‘v0.1’” command:

This creates the tag object in the .git/objects/ folder. If I run the “git cat-file tag v0.1” command:

This shows me the three items that make up a tag, object SHA1, type, and tagger. If I issue a regular “git show v0.1” against the new tag:

I see the tag information and also the information for the git object it points to; a git commit in this case.

refs

Consists of the master copy of all remote tracking branches (.git/refs/remotes), local branches (.git/refs/heads), tags (.git/refs/tags), and the stash (.git/refs/stash), when used. Master copy? What does that mean? Well, when I issue “git checkout dev” and checkout the checkout the master copy of the local dev branch, I’m replacing my working directory with a copy of .git/refs/heads/dev. If I then issue “git checkout master” I’m replacing my working directory with .git/refs/heads/master, or a master copy of the local master branch.

The .git/refs/heads/master file, in my case, points to the latest commit for the local master branch. In this case it’s the 41509ff SHA1:

Since we are in sync with the remote origin/master branch, the .git/refs/remotes/origin/master file points to the same SHA1:

The .git/refs/tags/v0.1 file points to the 8690e95 SHA1:

which is a Git tag object (.git/objects/86/90e95…) that points to commit 41509ff as we saw above in the Git tag object section. So what this means is that currently all my git refs point to the same commit, 41509ff, more or less.

There is another type of git ref, stash, that I will talk about in a future post, but just know for now that the stash is located at .git/refs/stash/.

COMMIT_EDITMSG

Consists of the last commit message. From other readings, this seems to not even be used by git and is simply hear for reference.

FETCH_HEAD

Consists of the SHA1s of branch/remote heads that were updated during the last “git fetch”. The last fetch occurred automatically when I pulled changes from my local user_prompt branch into my local master branch.

HEAD

Consists of the current reference that you are set to (usually a branch). Normally master (aka .git/refs/heads/master). I’m currently set to my local master branch.

ORIG_HEAD

Consists of the SHA1 of the branch I did the last “git merge” into. In this case it’s the SHA1 of my local master branch before I pulled in the changes of my local user_prompt branch.

config

Consists of the settings for this repository. I personally rarely edit this file and use the “git config …” command with options. Read here for all the possible settings. I highly recommend the “git config color.*” commands to set color for your git commands and results.

description

Consists of a description that will usually be displayed if I were hosting this repository on gitweb or with git instaweb.

index

This is the “staging area” I’ve talked about in the past two posts. This is the area you prepare so that you can make one commit to your local repository. It consists of meta-data such as filenames, timestamps, and SHA1s. DO NOT EDIT THIS FILE MANUALLY.

SUMMARY

That is a rough introduction to the .git folder. I mainly only ever interact with the config file and the hooks folder.

The two biggest concepts to take from this are the objects and refs. Objects are blobs, commits, trees, and tags. Refs are branches, remotes, tags, and the stash queue. Once you completely understand that, interacting with Git will most likely become easier.

My next post will be on tortoisegit to satisfy the GUI users amongst you. The following post will be concurrent development and then a post on little gotchas and lessons learned.

Git For Windows Developers – Git Series – Part 2

Jason Meridth — Thu, 04 Jun 2009 05:49:00 GMT

Git For Windows Developers - Git Series - Part 1

Git For Windows Developers - Git Series - Part 2

Git For Windows Developers - Git Series - Part 3

NOTICE: I know that there are good tools out there besides Git Bash. I will do a post talking about each one (tortoisegit, Git extensions, etc) after I get all the Git commands and scenarios squared away.

Please make sure you’ve read the first post and have created your SSH private and public keys. You should also have a very basic understanding of the git init, add, commit, and log commands. We will dive deeper on each of those. We also visit git checkout, pull (—squash), push, remote, diff, log, mv. I’ve done my best at making each git command that is mentioned in text to be of bold weight. Each image, if a command is involved, has that command in big text before it.

This post is going to go over my typical workflow for work. I’ll get as detailed as I can for this process:

git pull origin master
git checkout –b user_prompt
<code>
git add <filename> (as necessary)
git commit –a –m “commit message”
repeat step 3-5 as many times as necessary
git checkout master
git pull –-squash . user_prompt
git commit –a –m “add name validation and tests”
git pull origin master
git push origin master

For this example, we’re going to create a remote public git repository on Github.com. What is Github.com? Github.com is the most popular Git repository hosting website on the Internets (misspelled on purpose) today, in my opinion.

First, I’m going to create my github.com account. I go to http://www.github.com and click the “Pricing and Setup” link:

Next, I click the “Signup” link next to the “Free!” account (Once you get comfortable, upgrading is easy):

Now I need to copy my public ssh key (id_rsa.pub) that I created from the first post into the Windows clipboard, so I can paste it to the web UI on this next step. That means opening Notepad (Windows, type notepad and choose it from the results [Vista/Windows 7] or Start->Programs->Accessories->Notepad [2000/XP]) and choose File->Open and go to my user folder and then the .ssh folder and choose the id_rsa.pub (C:\Users\jmeridth\.ssh\id_rsa.pub). I noticed that the default file extension that notepad searched for was text files (*.txt). I had to change the drop-down in the bottom right corner to “All Files (*.*)” and then I was able to see my files in the .ssh folder. We are using notepad because it won’t put any hidden newlines into the content we are trying to copy and paste to Github.com. We will talk about this later in the post.

I chose the id_rsa.pub file and it showed in notepad.

Press ctrl+A and then ctrl+c (or Edit->Select All and Edit->Copy). Go back to the Github signup page and input your information. I paste (ctrl+v) the id_rsa.pub key I saved into the Windows clipboard into the SSH Key box:

I click “I agree, sign me up!” and I am taken to my dashboard (at least I think so, I’m not actually clicking this since I already have an account). I create the remote public repository for this series on Github.com by clicking the “Create a new one” link on the right side near “Your Repositories”.

I fill in the name, description, and web page for the repository. I’m sticking with the console_app:

I click “Create Repository” and I’m taken to a very informational page:

(the user.name and user.email suggestions are different than the examples above due to me creating this repository under my real github.com account).

Above this information is the part I need for this post:

Really, just this part:

I open Git Bash and go to my repository that I created in the last post (/c/code/console_app):

FINALLY, GIT COMMANDS:

GIT BRANCH

SIDE NOTE: You can clear your Git Bash screen by pressing Ctrl+L on the keyboard. This works in most bash terminals.

Normally, I run “git branch” to see what branch I am on, but msysgit let’s me know via the end of my bash prompt “(master)”. I’m going to check anyway:

The branch name with the asterisk (*) next to it is the active branch. In this case I only have the one branch, master. I paid particular attention the the “Existing Git Repo?” section of the informational page on my Github.com console_app information page:

GIT REMOTE

I already di the cd command (cd /c/code/console_app). I then type the “git remote …”:

What the? Okay, the command is “git remote” with the “add”, “origin”, and “git@github.com:armmer/console_app.git” parameters. The “git remote” command with the “add” parameter tells your local git repository that you are adding the path/URL/location of a remote repository that you want to watch. In this case we’re going to label this remote repository “origin” and the location is “git@github.com:armmer/console_app.git”.

SIDE NOTE: git@github.com:armmer/console_app.git doesn’t look like a HTTP URL or a ssh:// protocol. What protocol is that? It is still SSH. The git protocol, usually using port 9418, is used for clone, fetch, or pull (i.e., git://github.com/armmer/console_app.git). Please reference Stefan's comment below for more details.

Now I have told my local repository to watch my newly created github.com remote public repository.

GIT LOG

I run “git log” again to see the changes we made in the first post:

GIT PUSH

Okay, I am going to push this code up to the Github.com repository. Look at the last step of the “Existing Git Repo?” information from Github.com. I type the “git push origin master” command:

(UPDATE: This screenshot is a newer one and has the incorrect object count. This is to show the prompt for the host authenticity)

UPDATE: During the push, you will most likely get prompted for host authenticity. Make sure you type ‘yes’, the full word. Not just ‘y’. This will add github.com’s public RSA key to your ~/.ssh/known_hosts file so that you won’t get prompted for this again on any future push. This let’s your system know that you trust github.com and let’s github.com know that you trust it. After you say yes the files are pushed up to the remote repository.

Success!! It counted the objects, compressed them and wrote them up to the remote repository. This command translates to “I am pushing my local master branch to the master branch of the remote repository I have labelled origin”. Where does it mention the local master branch in that command? It doesn’t. It’s the convention. If no local branch is mentioned explicitly, the master branch is used.

SIDE NOTE: To push another local branch, I’d type “git push origin user_prompt:master” or “git push origin HEAD:master” if you just want to push the current local branch without having to remember it’s name.

Now we go back to the github.com repository main page and see the code and commit log:

My code is now remote and stored on Github.com. Sweet.

SIDE NOTE: If you get a “permission denied” or other errors, it is most likely ssh key related, hence, my emphasis on them. Check out this link for ideas/help.

GIT CHECKOUT

Now let’s imagine that we have a task that states “Prompt user for their name and say hello back to them, including their name”. I create a new branch locally so I have a separate place to do my active development for this task. I issue the command “git checkout -b user_prompt”.

A couple things to notice:

1. It says “Switched to a new branch ‘user_prompt’”. The “git checkout –b” command creates a new branch by the name following the command and then checks it out automatically. This is the shorthand version of doing “git branch user_prompt” and then “git checkout user_prompt”.

GIT BRANCH

2. It shows the “(user_prompt)” text at the end of my bash prompt now. That means that I’m on the user_prompt branch. To verify, I issue the “git branch” command. This lists all the local branches.

Again, the name with the asterisk (*) next to it is the active branch.

I make the code change:

(I have a “Console.ReadLine();” as the last line so the window doesn’t automatically close. I have to press a carriage return to close it. So I can read the output)

In all honesty, I wouldn’t test something like this, because I’d be testing the Framework. I test it manually and it works:

GIT STATUS

I commit my code to the repository. I run “git status” to see what the status is between the staging area and the working directory:

This tells me because I edited the Program.cs file it is “Changed by not updated”. What does that mean? It means it’s changed in my working directory, but not staged (not in my staging area or ready for commit). If I tried to commit right now, nothing would be committed because nothing is in my staging area.

GIT COMMIT

Example of running “git commit …” without adding files to the staging area:

GIT ADD

I add Program.cs to my staging area with the “git add Program.cs” command:

GIT STATUS

I run “git status” again:

The Program.cs file has been added to the staging area. How do you know that? Well, it is under the “Changes to be committed” section. That is synonymous with the staging area. Why don’t they just put that there: “Staging Area”? Good question. I don’t know.

SIDE NOTE: Notice every time I run “git status” the first thing I’m told is what branch I’m on. It’s nice to be reminded of that

GIT COMMIT

Now I commit it to the local repository with the “git commit –m ‘prompt user for name and say hello back’”:

Nice. Okay, we’re going to roll back, add the code again and commit in the “common” way. Huh? “Common way”? Most people do not do the “git add” and then “git commit –m …”. They, like myself, use the “git commit –a –m …”. The “-a” automatically adds all tracked changes from your working directory to the staging area. This does not include new files that aren’t tracked by the repository.

GIT RESET

I roll back one commit clearing my staging area and working directory with the “git reset --hard HEAD^” command:

What is the “HEAD^” portion of that command"? It means I want to reset the commits to one prior (^) to the HEAD (aka, the latest commit).

The result is “HEAD is now at 1731c83 initial commit”. That was the commit I did in the last post. This branch has been rolled back to that commit. The new commit I just did was destroyed from history. I will talk about undoing changes in greater detail in a future post. I run “git status” too and see that my working directory is clean.

SIDE NOTE: If you just want to clear your working directory and staging area, but not the latest commit, just issue a “git reset –-hard” command without the “HEAD^”

REFRESHER: What is the 1731c83? It is the first 7 digits of the SHA1 hash, talked about in the first post, that was assigned to my “initial commit”. Seven digits are all you need from the front of the commit to identify it uniquely.

GIT STATUS

I add the code change back and run “git status” again:

GIT COMMIT

Notice git even suggests the “git commit –a” notation? I run “git commit –a –m ‘prompt user for name and say hello back’”:

Same result as the “git add…” “git commit –m…”, just shorter syntax. Moving on.

Low and behold, the user then comes by and states, “Oh yeah, the name can’t have any numbers in it.” That' means I need to add more code. I could merge back to the master branch and push to my origin on Github.com and put this up as another task for the Story. For the sake of this post, I’m going to add the code here before the merge. Validation and specific business behavior makes me prepare for testing. I do my usual setup (lib folder with NUnit and break the main portion of the console app out to a class library and it’s test project). Uh oh, I realized I said “No” to the prompt to create a whole other folder for the projects. I have the solution file and the console_app project in the same folder.

So I move the project files and folders into their own folder and leave the console_app.sln file (and related files) in the current directory. I then change the project references inside the sln file, so that it can still reference the console_app project. Why don’t you just move the sln (and related files) up a directory? Unfortunately, the .git folder is at this level. If I move anything above this folder, it will be outside the local git repository. All folder and file moves need to be from this folder and down.

GIT MV

I make the moves with the “git mv” command:

(yes, to all of the current tortoisegit users, I believe if you select multiple files in windows explorer and move the files, it will do this for you)

So “git mv” takes a list of files, directories, or symlinks (for the *nix users) and will move them to the destination directory listed as the last option. This will do “git rename” to all the files and you won’t lose any history. (I chose “No” to the solution/project folder question at the beginning on purpose to show the “git mv” command here. Sure Jason, sure.)

GIT HELP

Site Note: I forgot the arguments for “git mv” and therefore typed “git help mv” into the Bash GUI:

Unlike on a *nix system, where you’ll just get the man page in the console, msysgit will open the web-based git help in your default browser:

I forgot, “git mv” even has a “—dry-run” option that will just show you if the move would succeed without errors. Did I mention how much I like git? :)

After the physical structure change, I manually test the console_app again and it still works:

GIT STATUS

I am going to commit these changes, so I have a stable place to come back to, just in case (Check-in early and often, right?). I first issue a “git status” to see what is in the staging area and what’s still in my working directory un-staged:

So, because we used “git mv” for the Program.cs, Properties folder, and the console_app.csproj file and they were already being tracked by the repository, they are in the staging area. We had to edit the console_app.sln file to point to the new console_app subfolder. The reason the renames are already in the staging area is because we did not edit their content, just moved them (a git, aka non-human, process).

GIT COMMIT

I commit the code with “git commit –a –m ‘restructure application to handle other projects, to allow for testing’”:

GIT LOG

We should now have three commits in our log, “git log”:

Now I add my two other projects (library and test) and the lib folder (containing NUnit):

GIT STATUS

I then run “git status”:

GIT ADD

Now I run “git add…” for each of the newly untracked items. If I committed right now, those items would not be put into the repository:

GIT COMMIT

I run “git commit –a –m ‘add library and tests projects to solution’”:

This is a decently sized commit due to the inclusion of lib/nunit.

SIDE NOTE: I love the ability to commit to my local repository knowing how I’m going to be able to merge to my local master branch as one commit and then push it up to the remote repository (coming soon). Via my lessons learned, as a software developer I sometimes have the tendency to go on a tangent and forget my training as a TDD Padawan. I make too many changes and break a lot more stuff than expected. Ctrl+Z (undo) works most of the time, but to just issue a “git reset --hard” and have my current branch reset back to the latest commit, clearing the working directory and staging area is priceless (as mentioned earlier).

I now write the tests and code for the name validation and run the tests:

Here are the tests:

and code:

GIT STATUS, GIT ADD, GIT COMMIT

I run “git status” to see the changes, and run “git add console_app.library/InvalidNameFormatException.cs”, and “git commit –a –m ‘add name validation with tests’”:

GIT STATUS

I run “git status” one more time verifying all the content is in my local repository.

Now comes the fun part of merging the changes back to the master branch so that we can push to the remote repository (is there an echo in here? hehe). There are at least three different ways to do this. I’m going to cover how I do it and will mention the others in future posts.

GIT CHECKOUT

I type “git checkout master” to switch back to the master branch:

GIT BRANCH

I issue the “git branch” command again to see that it switched. Again, you don’t have to do that because msysgit shows you the current branch you are in in the command prompt (promise, last time I’ll say it. Repetition works though. :) ).

GIT REMOTE

I type “git remote –v” to look at the remote repositories that I’m watching:

We are monitoring the “git@github.com:armmer/console_app.git” repository and have named it “origin”.

GIT PULL

I type “git pull –-squash . user_prompt”:

GIT STATUS

Whoa, that’s a lot of information. I type “git status” before I do the single (aka squashed) commit to the master branch:

… more new file references for nunit are below this. As you can see, everything that we committed in the user_prompt branch is staged in the master branch now (aka “Changes to be committed”).

GIT COMMIT

I type “git commit –a –m ‘add name validation with tests’”:

Everything is now committed on the master branch.

GIT STATUS

As usual, by now you know, I run “git status”:

GIT LOG

I type “git log” on master and I only see two commits:

That was the point of the squash. So you can do n number of commits in your “development” branch (in this case user_prompt) and turn it into one commit on master and then push only one commit to your remote repository. That is the power of a distributed source control. Local commits are priceless.

GIT PUSH

I finally type “git push origin master”:

This is the same as the original command we used to push our original commit to the Github.com repository. The command was explained above when we did it the first time.

And when I go to my github.com page I see the latest commit on the dashboard of the repository (same as the source tab):

When I click on the Commits tab, I see both commits, just like when I run “git log”:

GIT BRANCH

The last set of commands I issue are “git branch –D user_prompt”:

and “git branch” to make sure it is gone.

Phew! I know this is a _ton_ of images and information. There are other blogs and tutorials on git that show the commands and that it works, but I’ve been wanting to do a more visual blog entry and also give the side notes and insights I’ve learned.

The next post will be on the .git folder and it’s magic. Posts after that will consit of concurrent development scenarios, advanced Git commands, and GUI tools.

Thanks for reading.

Source Code for this post can be found here

Git For Windows Developers – Git Series - Part 1

Jason Meridth — Mon, 01 Jun 2009 06:04:00 GMT

Git For Windows Developers - Git Series - Part 1

Git For Windows Developers - Git Series - Part 2

Git For Windows Developers - Git Series - Part 3

This post is going to be the first of a few. I plan to convey everything I've learned the past 8 months while using git on a development team. I'm currently working on a Macbook Pro, doing Ruby on Rails development with git as the source control. These posts will be specific to using git on the Windows operating system.

This post is going to talk about installing msysgit, creating ssh keys, and creating a local git repository.

If you already have msysgit installed, have created your ssh keys, and have an existing application you just want to put in a git repository, go here

Installing msysgit On Windows

For windows, install msysgit (both ssh key generation capabilities and git come with this tool):

Download the latest version of msysgit:

Going through the setup. Click next past the first window.

Agree to the GPL terms:

Set the installation location (default was fine for me: C:\Program Files\Git):

The next screen asks what name the folder that the program will be available from when I click Start->Programs, etc:

Choose installation options. I don’t like to clutter my desktop, so that one is unchecked. The last two options give a user two new options on files when right-clicked in Windows Explorer. We’ll talk about this later in the post.

I use the “Git Bash only” option because it’s the only reason I downloaded msysgit. The other two options are tightly coupled to the operating system’s current setup.

UPDATE: Via Joshua Flanagan, I was informed that tortoisegit, a tool that will probably become the de facto way to use Git on Windows (we still need msysgit, but tortoisegit will be the UI tool of choice), suggests that you choose the second option "Run Git from the Windows Command Prompt". I've done both, I just prefer the first option because I don't use tortoisegit. Just be aware. I will mention tortoisegit and how to use it in a future post.

I use OpenSSH. It is the easier of the two to use, in my opinion.

I like to keep the line endings to the Windows style since that is what I’ll be operating on. Interaction with Gthub.com or other operating systems will cause line ending settings to be addressed. Those options will be mentioned in later posts.

Click next and the installation starts.

Uncheck the readme (who reads those anyway?) and click Finish.

Once installed, when I click the Windows button and type git (since I’m using Windows 7) I’ll see “Git Bash”, “Git Gui'”, “Uninstall Git”. Click “Git Bash”. Once I have the git bash open, I run “git –version” to make sure everything is working:

I also issue the following commands, “git config –global user.email my@email.com” and “git config –global user.name ‘Jason Meridth’”:

After I commit code in my new repository, later in the post, we will see why these are relevant.

Generating SSH Keys

I’ve met a good number of Windows developers who don’t know what SSH is. My quick definition of Secure Shell (aka SSH): A secure connection mechanism to other networked machines that support SSH, usually over port 22. It is pretty much the default form of remote communication for other platforms. More information if you're interested.

History and Retrospective:
I used to use cygwin + ssh keys for my git stuff on my windows VMs, but have realized, via advice from a friend, that cygwin will not be the easiest thing to teach to a typical Windows user. I am in no way assuming that any of our readers are "typical" windows users, but he's right. And msysgit needs to become the defacto Windows git tool anyway. What better way to help that project succeed than to give it more users.

I’ll generate the SSH Keys I will use to need to connect to remote repositories. I issue the following command “ssh-keygen –C ‘your@mail.com’ –t rsa” (using your own email address of course) and then press enter when prompted on file location and return two more times on both passphrase questions:

This will create two files in my /c/Users/jmeridth/.ssh folder. These files are my private and public keys (id_rsa and id_rsa.pub). The public key is the one we will be moving to remote git repository servers in later posts.

SIDE NOTE: back up these keys to a secure location. If they accidentally get corrupted, deleted, or changed you will be able to restore them at any time. I type “secure” because you need to make sure no one gets a hold of your private key. If either of those situations occur you can just recreate the keys, but every server that already has your public key will need the new public key (kind of a headache and time consuming). I’m speaking from experience on this.

This process will not apply to the remainder of this post, but will for following posts.

Putting My Code Under Source Control With Git

For example’s sake, say we have a folder under C:\code. In that folder we’ve created a folder called “console_app”. Inside this folder is a .NET 3.5 Console application that will send “hello world” to the output. Really? Again? Yep.

The easiest thing that works:

I built the application to ensure the bin and obj folders are created. I’ll explain why in a minute. In windows explorer I went to the C:\code\ folder. I right-click the console_app folder. Notice the two choices of “Git GUI Here” and “Git Bash Here”. When chosen they will open the corresponding msysgit tools at that desired location.

Each of these choices shows the two different ways of creating a local git repository or converting an existing folder into a git repository. I will show how to use Git Bash in this post and will use it mainly in this series. (If I get enough response to show Git GUI, I may do that)

Turning the Console Application Into A Git Repository With Git Bash

Choosing “Git Bash Here” when right-clicking the C:\code\console_app folder gave me the following:

Pretty much what I’ve already seen, but notice the path “/c/code/console_app”. For the individuals who aren’t used to a *nix type path structure, that is the same as C:\code\console_app.

Finally, Git Commands

In the prompt, type “git init”:

I just turned my folder into a git repository. Really that easy? Yep. Notice the folder mentioned in the response to the command. The .git folder. For the subversion users who are reading: Remember how you’d have a .svn folder under every directory of your repository? Not with git. You only have the one .git folder. If you delete that, you’re folder is no longer a git repository. Yes, it’s that easy.

Also, notice the “(master)” on the end of our prompt. That is a nice feature of msysgit. It is telling me what git branch I’m are currently in. We will talk more about that in a future post. I mention it in case anyone notices the new prompt.

Now issue a “git status”:

I will explain this output in a second. I need to create a .gitignore file first. Why? You notice that the bin and obj folders and the _ReSharper files are listed? I don’t want to include those items in our repository. Why? Those are items that another developer doesn’t need to successfully get the source and compile. They are specific to my local environment.

I tried to create a .gitignore file in Winodws Explorer and kept getting this error:

Windows doesn’t understand dot files (i.e., .bashrc, .gitignore, etc). Windows expects your files to have a name.extension convention.

<sarcasm>My love for Windows grows every time I use it</sarcasm>

Remember I said I was building the application for a specific reason (aka the bin and obj folders)? It was to highlight the necessity of the .gitignore file and how it can explicitly exclude files from your repository. I go into the Git Bash, at the C:\code\console_app folder. I type “ls –al” to list all the files, including dot files. Notice we have .git, but no .gitignore. I type “touch .gitignore”. This will create the .gitignore file with no content. Issuing “ls –al” again and you see the new file.

Now I edit the file in vim, my favorite editor, which came with msysgit. I could use any text editor (i.e., notepad, wordpad, notepad++, etc)

I add the following to it:

I save the file.

Now I issue a “git status” again and the bin and obj folders and ReSharper files are not shown. I do now have the .gitignore file listed, but that was expected.

Alright. Hopefully you are either saying, “yeah, I know, I have to add the files to my staging area, and then commit them to my local repository” or “what the heck is that?”. Maybe even something between like, “I know I have to add them to the repository….wait, what is a staging area?”.

Here is a picture that illustrates what the basic interactions with a local git repository consist of:

(http://learn.github.com/images/staging.png)

Ignore the “checkout the project” red arrow. Focus on the “stage files” and “commit” red arrows. Those are the actions you need to take to place/update files in your local repository. So, currently, all the files for my console_app application are in my working directory. I need to put them into the staging area before committing them to the local repository.

Common Questions:

Q: Aren’t we in a folder already? How does git know what’s in and what’s not in the local repository?
A: The .git folder (we will dive deep on that folder in a future blog post)

Q: What does the staging area give me?
A: A prepared set of files that you have ready to commit to the local repository.

So I issue the “git add .” command:

And I issue “git status” again:

Now the files are shown as “Changes to be committed”. Git even shows me how to remove files from the staging area; “git rm –cached <file>”.

I now issue the “git commit –m <message>” command:

The “-m" and subsequent text is the message that is assigned to the commit. I see the files get added.

I now issue the familiar “git status” command:

“nothing to commit (working directory clean)”. Cool. All of my files are now initialized in the git version control system. How do I see what has been committed to this repository? Good question. Just issue the “git log” command:

Remember those two git config calls we made earlier? This is where those are relevant. They populated the Author information for the commit. What are those numbers after the commit word? Those are the SHA1 (secure hash algorithm) hash assigned to this commit. SHA1 hashes are “unique”. Why do I have unique in quotes? Go read this.

I think that is enough for now and if you have any questions, please leave a comment. I will update this post upon necessity. In the next few posts I will be going over the common commands (clone, push, pull, fetch, merge, rebase, remote, branch, etc). I will also show you how to interact with Github.com, a remote git repository via ssh on a LInux box, and Gitosis, a mutli-user and multi-git repository management tool. I will also show how to setup gitweb, an easy to use web-based viewer of your repositories. I will be using the Linux operating system for all the remote servers. The local git commands should be applicable to all platforms once you have git installed correctly.

I actually have a good portion of the next post already written and will complete it soon.

LosTechies welcomes Ryan Svihla

Jason Meridth — Thu, 21 May 2009 17:07:20 GMT

We are happy to announce a new member, Ryan Svihla. Ryan is an active member of the San Antonio software development community. Ryan regularly attends and contributes to AlamoCoders, The San Antonio Tech Book Club, and SA Ruby. His prior blog writing are at http://ryansvihla.blogspot.com/. If you get a chance, go check it out.

Ryan is the primary developer on the following 2 OSS projects (among others):

Pinsor (IoC in Python)
SpecMaker (C# BDD Framework)

He currently works for a local San Antonio Bank and helped them get their production site to use the Castle stack. He is very passionate about his craft and we look forward to him helping us contribute to the software development community.

Welcome to the group Ryan.

TextMate and Community Server 2008.5

Jason Meridth — Thu, 21 May 2009 08:32:38 GMT

This is my first blog post from TextMate on my Mac. I'm using the HTML formatting. I will try the markdown and textile versions later. The key to getting this working with Community Server was when you click "Bundles->Blogging->Setup Blogs" and the following template shows up:

# List of Blogs
#
# Enter a blog name followed by the endpoint URL
#
# Blog Name URL

you put the following underneath the commented header

My Blog Name http://username@www.mydomain.com/blogs/<api_key>/metablog.ashx#<api_key>

The key part is #<api_key>. api_key in Community Server terms is the portion of your url after domain/blogs/ and before the page requested. Mine is jason_meridth. My full URL for TextMate blogging would be http://myusername_notsharing@www.lostechies.com/blogs/jason_meridth/metablog.ashx#jason_meridth.

Hope this may help a fellow Mac brethren

San Antonio community

Jason Meridth — Tue, 21 Apr 2009 14:53:00 GMT

This list is for any developers in the San Antonio, TX area. These are the communities that are growing/starting that I've been involved (member/leader). If anyone knows of others please leave a comment and I'll update the post. (Man we love our Tuesdays in San Antonio, every Tuesday is a group meeting)

Alamo Coders (organizer Phil Dennis)

http://www.alamocoders.net

Welcome to Alamo Coders. We are a FREE San Antonio area IT professionals Users Group that focus on the tools, technologies, and programming languages that help a software developer/architect/manager in today's industry. If would like to learn more about software development or the tools that are involved in that process, or if you just want to learn more about what Alamo Coders has to offer the San Antonio area IT community, then please join our group.

To get AlamoCoders Apparel, please go to our CafePress store.

MEETINGS: 2nd TUESDAY OF EVERY MONTH (@ New Horizons)

San Antonio Tech Book Club (organizer Anne Epstein)

http://groups.google.com/group/san-antonio-tech-book-club

Our next meeting:
Where: Skype
When: 4/21/2009 (Tuesday) at 7pm
Current Book: Implementing Lean Software Development: From Concept to Cash
Topic: Chapters 1 & 2

NOTE: On 5/5/2009 we'll be going back to our other book, Domain Driven Design by Eric Evans
and switching off between the books. Following meeting will be back to Lean, meeting after that will be DDD again, etc.

MEETINGS: 1st & 3rd TUESDAY OF EVERY MONTH (Skype)

Google Calendar

SARuby (organizer TBD)

http://www.saruby.org

There is now a SARuby group in San Antonio. This month's meeting is Tuesday, April 28 @ 6:30 pm. It is at Anderson Marketing Group (Thanks to Nate for providing the location). Map: http://tinyurl.com/ckl43y

MEETINGS: LAST TUESDAY OF EVERY MONTH (@ Anderson Marketing)

More detailed meeting information

LosTechies welcomes James Gregory

Jason Meridth — Fri, 27 Mar 2009 14:21:00 GMT

We are happy to announce a new member, James Gregory. If you're in the NHibernate world you'll recognize him as the lead developer on the Fluent NHibernate project. He recently took on the Docu project for .NET documentation and is working with a few other projects. His home page sums up his information perfectly. James is definitely a pragmatic programmer and is a perfect fit for us. Here are some of James' links.

His LosTechies blog is located at http://jagregory.lostechies.com

Homepage: http://jagregory.com
Blog: http://blog.jagregory.com
Twitter: http://twitter.com/jagregory
Github Repos: http://github.com/jagregory

OSS Projects
Docu: http://docu.jagregory.com
FluentNHibernate: http://fluentnhibernate.org/
BooLangStudio: http://www.codeplex.com/BooLangStudio

Welcome to the group James.

Adding a git post-receive hook to fire off Hudson CI server

Jason Meridth — Tue, 24 Mar 2009 18:07:00 GMT

UPDATE: guard clause throws LocalJumpError. Changed to simple if block Context: I needed our hudson CI builds to auto-fire when a developer pushes their code changes to our canonical/upstream git repositories. In your .git/hooks/post-receive file place the file code (FULL CODE):

#!/usr/bin/env ruby
#   
while (input = STDIN.read) != ''
   rev_old, rev_new, ref = input.split(" ")
   if ref == "refs/heads/master"

       url="http://yourhudsondomain.com/job/job_name_here/build?delay=0sec"

       puts "Run Hudson build for job_name_here application"
       `wget #{url} > /dev/null 2>&1`
   end
end

EXPLAINING EACH LINE: I avoid writing bash scripts in default bash if I can. This is for a Ruby on Rails app, so I decided to write it in Ruby.

#!/usr/bin/env ruby

The while loop checks to make sure there are values in STDIN (by default they are rev_old, rev_new, and ref).

#   
while (input = STDIN.read) != ''
end

I put an if statement block:

if ref == "refs/heads/master"
end

to make sure I only fire the build if it is the master branch. Set the URL for the app you want to build:

url="http://yourhudsondomain.com/job/job_name_here/build?delay=0sec"

Add a little text to notify the user what is going on (always a good idea):

puts "Run Hudson build for job_name_here application"

And finally all the url with wget and feeding any response to the black hole that is /dev/null

`wget #{url} > /dev/null 2>&1`

IMPORTANT: Don't forget to run:

chmod a+x .git/hooks/post-receive

so that the file can be run Some Gotchas: 1. If you are going to a url that has http basic authentication like my actual script does, you can pass the username and password like you normally would in an HTTP call:

url="http://username:password@yourhudsondomain.com/job/job_name_here/build?delay=0sec"

2. If you are doing an https call with a self-signed certificate, wget will complain. You can add the --no-check-certificate argument to wget to bypass certificate validation against local certificate caches:

`wget --no-check-certificate #{url} > /dev/null 2>&1`