Having just had the unfortunate need to use rhino mocks from managed C++ I thought I would document the “how”

Let’s say you want to mock/stub IFoo. Which has two methods:

• IQux Bar()
• int Baz(int)

Create a MockRepository:

IFoo^ foo_stub = MockRepository::GenerateStub<IFoo^>();

Stub out Bar() -> Note it doesn’t take a parameter:

Rhino::Mocks::Function<IFoo^, IQux^>^ foo_bar =
    gcnew Rhino::Mocks::Function<IFoo^, IQux^>(&IFoo::Bar);

RhinoMocksExtensions::Stub(foo_stub, foo_bar)->Return(
    /* Another mock/stub or a real IQux */
);

Stub out Baz() -> Note it takes a parameter:

Note, the static method, this will configure the stub for a specific argument, in this example when Baz(1) is called we return 2.

Rhino::Mocks::Function<IFoo^, int>^ foo_baz =
    gcnew Rhino::Mocks::Function<IFoo^, int>(&Test::FooStubBaz);

RhinoMocksExtensions::Stub(foo_stub, foo_baz)->Return(2);

// IFoo will actually be a rhino mock/stub
int Test::FooStubBaz(IFoo^ foo) {
    return foo->Baz(1);
}

Now foo_stub->Baz(1) will return 2

I imagine you could remove the need for a static method but this was enough for my needs and my head!

I have recently been playing with the NeuroSky mindset – I have always found this subject fascinating…

Unfortunately the device didn’t come with any Linux software so I decided to write some using ruby. Had a good run at coding this weekend and I’m now finalising the gem – Hope to have it up on git hub and ruby forge this week. I can then move onto coding some fun software on top. Doubt it will have a huge demand but at least it will make using the device a little easier on Linux (and Windows), I needed it so at least one person will benefit!

Update: I have placed an almost finished (just some documentation tidying left) version on GitHub

I’ve been thinking about agile/LEAN feedback loops lately, primarily how I could introduce fun ways to kick start them and hopefully keep them maintained. With this in mind my thoughts turned to the “commit” process. It’s something all developers do (hopefully else your coding without revision control) and provides a nice point in time to inject some automated feedback.

The idea is to have each commit analysed for some simple “agile” metrics, nothing too complex or tricky, examples:

• Did the commit touch unit tests
• Was the commit “small”

I imagine you could also run a few simple code quality algorithms also (ones that are regarded as being sensible) and maybe a copy and paste checker. Overall the main aim is to find around three or four simple metrics that the team can agree on that signify good practice.

Then the fun starts, you normalise the values and plug them into a simple fighting game, where they impact the fighters abilities (and looks?), clearly weighted towards the better the metrics, the better the fighter. This new fighter then battles the current one (winner of the last commit war) to see who remains king of the hill.

The whole fight can be e-mailed back as a small movie, statistics can also be kept – If you commit small, unit tested code often you have a high chance of ranking highly.

Think I will code this up. Also wondered about wiring the commit to net hack or an adventure game, I.e. your commit log would contain a string for your next move, on commit you are e-mailed a response. E.g.

# open door

<commit>

"You see a wolf"

Fun, possibly, but not where I was heading.

It started with a conversation in a pub (don’t most things?) related to porting “old” code to newer languages. With my interest in TinyMud I decided to take on the challenge of porting the original c-code to Ruby.

This is now becoming an intense labour of love! I’m wrapping the old TinyMud code as Ruby extensions and writing as many test cases as I can. I’m over half way through now. The idea being to get good test coverage of the c-code (in Ruby) then switch to Ruby equivalent code – Then re-factor to a more Ruby’esque style.

I have to say I’m impressed by the original source code (although I’m finding some edge case defects). I wonder if the Ruby code will be any more compact? Intending to put the result on GitHub at some point – For now it’s a one man mission!

Once complete I will run this on a server and prove wikipedia (sort of) wrong, I quote “No active games currently run on a TinyMUD server”. I could host the original (and I’m in a position to), but I think running a modernised equivalent would be more interesting.

In pseudo code:

queue = ....new() # Not a ruby "queue" (see why below), but "thread safe"

a,b,c,.. = Thread.new do
    begin
        queue.pop
        ...Compute stuff...
        queue.push(stuff) if stuff
    end while !queue.done? # i.e. empty? or done
end

trap CTRL-C { queue.done = true }
a,b,c,...join

The problem I had was if “queue.pop” was blocking e.g. I used a ruby queue, then “main” could enter deadlock, e.g. imagine the queue had one item, thread “a” takes the first item, the remaining threads block. Unless “a” pushes new content then it causes deadlock as “b,c..” are left and “waiting”.

Note: This is a slightly weird case of producer and consumer in one. Essentially you can’t stop processing until all the input has been consumed and processed (as the last item might generate more content for processing).

The following is my solution:

def initialize(initial = nil)
     @user_cancelled = false
     @items = []
     @removing_mutex = Mutex.new
     @check_removing = ConditionVariable.new
     @items_mutex = Mutex.new
     @removing = 0
end

def pop()
    @removing_mutex.lock
    item = @items.shift
    while (@removing > 0) and item.nil?
        @check_removing.wait(@removing_mutex)
        item = @items.shift
    end
    if item.nil?
        @check_removing.signal
        @removing_mutex.unlock
    else
        @removing += 1
        @removing_mutex.unlock
        begin
           @processed << (yield item)
        ensure
           @removing_mutex.lock
           @removing -= 1
           @check_removing.signal
           @removing_mutex.unlock
        end
    end
    return !(@user_cancelled or item.nil?)
end

def push(item)
    @items_mutex.synchronize do
        @items << item
    end
end

def kill()
   @user_cancelled = true
end

The loop becomes:

a,b,c,.. = Thread.new do
    ok = true
    while ok
        ok = queue.pop do |item|
            ...Compute stuff...
            queue.push(stuff) if stuff
        end
    end
end

It’s taken me more than my highly underestimated “few days” to complete, but  I now have a version of my ruby based search tool up on github, it’s called “Poodle”.  Feel free to use/contribute to, more information here.

It still requires some more work (hence the “0.9″ revision number), hopefully someone else will find it of use and help out.

I have been researching search tools for our Intranet/enterprise, after looking at Nutch, MS search server 2010 (express) and plenty of others I decided to write my own, why? A fair question, basically they all had something not quite right about them, varying from rubbish web-front ends to an inability to authenticate with NTLM or go through proxies. Lastly, I thought it would be fun!

The result – I’m almost done, 3 hours of coding! I didn’t start from scratch though, I wrote a simple ruby crawler, wired it to Apache Solr and wrote a rails application to call out to Solr and display the results (no rails database involved – Which differs from the normal RoR and Solr configuration). The RoR application even supports open-search.

The result is excellent! Just fine tuning now and tidying, I will put the code up in a day or two – It will be instructive if nothing else…

[The code is now on Github: https://github.com/mangled/Poodle]

Recently I needed to create a script to make a single movie from static images and existing movie files. I hacked this together with ruby, ffmpeg and ImageMagick. Note, it will function under windows with little code change.

Putting it up in case someone finds it of use!

#!/usr/bin/ruby
require 'fileutils'

# !! Script requires image magick to be installed (for convert) and ffmpeg !!
#
# This was *hacked* up quickly, apologies for the general cr*ppy style, its
# functional but not beautiful!
#
# Note: I pipe ffmpeg output (STDOUT/STDERR) to /dev/null - If ffmpeg fails to
# convert you might want to remove this "feature".
#
# Also note you will have to change jpg_to_mpeg() to alter how long static
# images play for.
#
# Also, also note, its hardcoded to look for specific file extensions, you
# might want to alter these as well.
#

# For a given folder, find a unique filename of random string + post_fix
def unique_filename_at(folder, post_fix)
  name = nil
  begin
    name = File.join(folder, ((1..8).map{|i| ('a'..'z').to_a[rand(26)]}.join) + post_fix)
  end while File.exists?(name)
  name
end

# Resize all image files in env[:src] writing them to env[:dst]
def resize_images_as_jpg(env)
  resized_names = []
  images = Dir.glob(File.join(env[:src], '*.{jpg}'), File::FNM_CASEFOLD)
  images.each do |image|
    resized_names << unique_filename_at(env[:dst], ".jpg")     `convert -scale #{env[:width]}x#{env[:height]} #{image} #{resized_names[-1]}`     `identify #{resized_names[-1]}` =~ /(\d+)x(\d+)/     # Scale attempts to best fit (based on image aspect ratio), it doesn't guarantee the exact size, so     # add extents (pad) the image to one which has the desired dimensions     if (env[:width] - $1.to_i) > 0 or (env[:height] - $2.to_i) > 0
      `convert -gravity Center -extent #{env[:width]}x#{env[:height]} #{resized_names[-1]} #{resized_names[-1]}`
    end
  end
  resized_names
end

# Resize all the movie files in env[:src] writing them to env[:dst]
def resize_movies(env)
  resized_names = []
  movies = Dir.glob(File.join(env[:src], '*.{mpg,mp4,flv}'), File::FNM_CASEFOLD)
  movies.each do |movie|
    resized_names << unique_filename_at(env[:dst], ".mpg")     `ffmpeg -i #{movie} -s #{env[:width]}x#{env[:height]} -sameq -r 25 #{resized_names[-1]} > /dev/null 2>&1`
  end
  resized_names
end

# Convert the given file (must end .jpg) to an mpeg
# !! Hard-coded to create movies of length 10 seconds
# !! 25 frames per second and 250 frames in total
def jpg_to_mpeg(file)
  movie_name = File.join(File.dirname(file), File.basename(file, ".jpg") + ".mpg")
  `ffmpeg -loop_input -qscale 1 -f image2 -vframes 250 -r 25 -i #{file} #{movie_name} > /dev/null 2>&1`
  movie_name
end

# Usage: tomov src_folder dest_folder
# src_folder contains images/movies
# dest_folder will contain the final result
if __FILE__ == $0

  # Change this to set the resultant video size
  env = { :width => 640, :height => 480 }

  # Get src/dest folders - I didn't care about fancy argument checks at the time...
  if ARGV.length != 2
      puts "tomov in_folder out_folder"
      exit(-1)
  end
  env[:src] = ARGV[0]
  env[:dst] = ARGV[1]
  exit(-1) unless File.exists?(env[:src])
  exit(-1) unless File.exists?(env[:dst])

  # Get the movie files to be consistent
  movies = resize_movies(env)

  # Get the image files to be consistent and convert to movie files
  resized_images = resize_images_as_jpg(env)
  movies.concat(resized_images.collect {|resized_image| jpg_to_mpeg(resized_image) })

  out_tmp = File.join(env[:dst], "movie.mpg")
  out_final = File.join(env[:dst], "final.avi")

  # Concat individual movies into a single movie
  # (the sort tries to ensure video's and images are mingled (not guaranteed though))
  `cat #{movies.sort_by{rand}.join(" ")} > #{out_tmp}`

  # Ensure the final movie is consistent and the format I want...
  `ffmpeg -i #{out_tmp} -sameq -vcodec mpeg4 -an -r 25 #{out_final} > /dev/null 2>&1`

  # Clean-up intermediate files
  File.delete(out_tmp)
  resized_images.each {|i| File.delete(i) }
  movies.each {|i| File.delete(i) }
end

A random script I hacked together (through searching and experimentation) for pulling down videos from YouTube with ruby, its only guaranteed to last along as the current YouTube html formatting lasts.

Will work under windows, with some minor changes (and installation of curl and ffmpeg). Usage should be obvious, it takes the YouTube url (with watch? in it) as an argument (try quoting “”)

#!/usr/bin/ruby
require 'rubygems'
require 'hpricot'
require 'open-uri'

USER_AGENT = %{Mozilla/5.0 (X11; U; Linux i686; en-GB; rv:1.9.2.3) Gecko/20100423 Ubuntu/10.04 (lucid) Firefox/3.6.3}

def parse_youtube(url)
  youtube = "http://www.youtube.com/"
  url =~ /watch\?v=(.*)/
  doc = Hpricot(open("#{youtube}watch\?v=#{$1.split("&")[0]}"))
  doc.search("/html/body/").each do |foo|
    matches = URI.unescape(foo.inner_html).scan(/\|(.*?http.+?),.*?\|/)
    matches.each do |match|
      match.each do |item|
        return URI.unescape(item) if item =~ /videoplayback/
      end
    end
  end
  nil
end

if __FILE__ == $0 and ARGV[0]
  url = parse_youtube(ARGV[0])
  `curl -o \"foo.flv\" -L -A \"#{USER_AGENT}\" \"#{url}\"`
end

I.e. write code in the wiki, configure the build similarly, i.e. which pages will be compiled. Modern wiki’s have configuration management built in, so bye bye svn, git etc. (ok, wiki’s don’t handle this well enough, but again this is an idea not a real product).

The environment by itself supports cross linking, so it self documents and people find it easy to document! The compiler and automated tests can update a build/test result page! With a little thought I think a wiki could manage code better than current IDE’s and integrate the social side. I guess execution of code might be an issue, but one which some more thought would overcome. Possibly this could be integrated into Google Wave?

It’s worth some discussion and further thought – Somewhere, off to bed!