Also available as Gist

Ever wondered how much who adds/removes, its time to find out
(those are real stats, I just obfuscated the names )

Results

Git scores (in LOC):
mr-add              :  +482273       -9466
justu               :  +286250       -159905
grosser             :  +152384       -323344
another             :  +121257       -82116
naames              :  +104577       -13591
justfor             :  +68716        -72446
example             :  +7795         -4987
andeven             :  +5100         -1730
morenow             :  +4225         -2764
finish              :  +17           -19

Install
Copy init git_stats.rb and ruby git_stats.rb
(you can add the names of people who commit with different users into the ’same’ array)

# please add enhancements to http://gist.github.com/234560
#!/usr/bin/env ruby
t = Time.now

same = [['name-a','name-b'],['mr fred','fred']]
pipe = open("|git log --shortstat")
author = "unknown"
stats = {}

loop do
  line = pipe.readline rescue break
  author = $1 if line =~ /Author\: ([a-z]+) </
  found = same.detect{|a| a.include?(author)}
  author = found.first if found

  if line =~  /files changed, (\d+) insertions\(\+\), (\d+) deletions/
    stats[author] ||= Hash.new(0)
    stats[author]['+']+=$1.to_i
    stats[author]['-']+=$2.to_i
    print '.'
  end
end

puts "\nGit scores (in LOC):"
puts stats.sort_by{|a,d| -d['+'] }.map{|author, data| "#{author.ljust(20)}:  +#{data['+'].to_s.ljust(10)}   -#{data['-'].to_s.ljust(10)} " } * "\n"

A new version of the old pass/block hack, but this time they also work as expected on HashWithIndifferentAccess (params/session…)

When attr_protected or attr_accessible are just to complicated, a simple user.attributes = params[:user].pass(:name, :email) just works.
Or user.attributes = params[:user].block(:admin) for the opposite…

# lets through the keys in the argument
# >> {:one => 1, :two => 2, :three => 3}.pass(:one)
# => {:one=>1}
def pass(*selected_keys)
  tmp = self.dup
  dup.block(*selected_keys).keys.each{|k| tmp.delete k }
  tmp
end

# blocks the keys in the arguments
# >> {:one => 1, :two => 2, :three => 3}.block(:one)
# => {:two=>2, :three=>3}
def block(*blocked_keys)
  tmp = self.dup
  blocked_keys.each{|k| tmp.delete k }
  tmp
end

Again I read an article about background processing that generates many different jobs which all do the same: call method a on b with parameter z. At the moment we are using one GenericJob to handle all those cases.

It serializes ActiveRecord objects to a string representation, so that they do not get submittet as instance(often too large or deserialisation problems), if you do not need this feature, :send_later could be a good option for starting with generic jobs.

Usage

GenericJob.publish UserMailer, :deliver_notification,
  :args=>[user, comment], :priority=>2

Install

class GenericJob < DelayedJobBase
  DEFAULT_JOB_PRIORITY = 5

  # GenericJob.publish( Product, :find, :args=>[:all, {:conditions=>"1 = 2"}], :priority=>3 )
  def self.publish(klass, method, options={})
    args = options[:args] || []
    args = GenericJob.serialize_ar(args)
    priority = options[:priority] || DEFAULT_JOB_PRIORITY
    Delayed::Job.enqueue self.new(:class_name => klass.to_s, :method_name => method, :args => args), priority
  end

  def perform
    klass = message[:class_name].constantize
    args = GenericJob.deserialize_ar(message[:args]||[])
    klass.send(message[:method_name], *args)
  end

  private

  def self.serialize_ar(args)
    args.map do |arg|
      if arg.is_a?(ActiveRecord::Base)
        "ActiveRecord:#{arg.class}:#{arg.id}"
      else
        arg
      end
    end
  end

  def self.deserialize_ar(args)
    args.map do |arg|
      if arg.to_s =~ /^ActiveRecord:(\w+):(\d+)$/
        $1.constantize.find($2)
      else
        arg
      end
    end
  end
end

Since my old Ubuntu lived a long live and saw numerous hacks, I chose to reinstall from scratch, here are the steps I took:

1. install dotfiles
2. Skype
3. Multi-clipboard: sudo apt-get install glipper
4. Application laucher: sudo apt-get install gnome-do + enable skype plugin
5. Ruby enterprise
6. Rubymine + Desktop icon+ Meta key for Rubymine
7. Mysql: sudo apt-get install mysql-server mysql-client libmysql-ruby
8. Apache:  sudo apt-get install apache2 apache2-mpm-prefork apache2-prefork-dev
9. Passenger
10. SSL for apache/passenger
11. gem sources -a http://gems.github.com
12. gems…
13. Java: sudo apt-get install sun-java6-jre
14. Git: sudo apt-get install git-core

No more hacks, everything works, very fast startup (~10s), faster graphics (for intel chips)

My new desktop

Making a certificate

sudo mkdir /etc/apache2/ssl
sudo /usr/sbin/make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem

sudo nano /etc/apache2/sites-available/default-ssl
  #deactivete other crt/key files (snakeoil)
  SSLCertificateFile /etc/apache2/ssl/apache.pem

sudo a2ensite default-ssl
sudo a2enmod ssl
sudo /etc/init.d/apache2 restart

Configure passenger

<VirtualHost *:80>
 ServerAlias *.something.com
 RailsEnv development
 DocumentRoot /apps/something/public
</VirtualHost>
<VirtualHost *:443>
 SSLEngine on
 SSLCertificateFile /etc/apache2/ssl/apache.pem
 ServerAlias *.something.com
 RailsEnv development
 DocumentRoot /apps/something/public
</VirtualHost>

host

params[:id].present?
nil.present?

( the original post was a hack adding String.filled? / NilClass.filled? )

# descriptive raise
# normale: raise 1 == TypeError: exception class/object expected
# now: raise 1 == RuntimeError: 1
class Object
  def raise_with_helpfulness(*args)
    raise_without_helpfulness(*args)
  rescue TypeError => e
    raise_without_helpfulness args.first.inspect if e.to_s == 'exception class/object expected'
    raise e
  end
  alias_method_chain :raise, :helpfulness

I recently did the switch and it was fun, and now I finally got everything working, here are the steps I took:

• Install rubymine and make a shortcut
• Use Textmate style shortcuts (so I can work with all the evil textmaters out there :> )
• Correct Meta key behaviour:
  1. change LWIN in /usr/share/X11/xkb/symbols/pc
  key <LWIN> {        [ Meta_L, Super_L       ]       };
  2. System > administration > keyboard > layout options
  choose meta is mapped to left win
• fuzzy autocomplete / Textmate Esc autocomplete is called “cyclic completion”, find it in keymap and replace it with Esc
• add ctrl+c/v/x/z/… shortcuts so rubymine behaves like all the other apps

Benefits:

• great fuzzy file search e.g. “ba/us/in” -> app/backend/users/index.erb
• Fast autocompletion
• Nice refactoring with preview
• Warnings / hints on local / global / unused variables and sane spellchecking
• Tons of options for whitespace/editor layout
• Integrated git with visible history
• “click something and got to its definition” works great

Drawbacks

• Startup takes ~30s for large app (initial indexing took ~ 4min)
• To many menu entries, but they can be customized out…

If you noticed spork startup getting slower when switching to Rails 2.3, your not alone

• Views are eager loaded
• app/ is eager loaded (when config.cache_classes is on)

Without hack: 18s startup
With hack: 2s startup

Try it

#spec/spec_helper.rb
begin
  require 'spork/app_framework/rails'
  module Spork::AppFramework::Rails::NinjaPatcher
    # views are preloaded  spork must be restarted for view changes
    def delay_eager_view_loading
      puts "removed because i am too slow..."
    end

    # do not preload application files
    # alternatively urn off config.cache_classes
    def delay_app_preload
      ::Rails::Initializer.send(:define_method, :load_application_classes) do
      end
    end
  end
rescue
end

Spork.prefork do
  ...

If you got a big project, chances are spec_helper is required through different ways, File.expand_path / File.join() / … which results in it being loaded several times!

Try it:

#spec_helper.rb
print "YEP!"

rake spec -> “YEP!YEP!YEP!YEP!YEP!YEP!YEP!YEP!……”

So how to prevent it ?

Unify!
Unify it to ’spec/spec_helper’ which is dead-simple, can be copied without modification (like adding ‘../../’) and prevents duplicate spec_helper calls

#unify_spec_helper.rb
require 'rake'

files = FileList["spec/**/*_spec.rb"].reject{|file|File.directory?(file)}
files.each do |file|
  lines = File.readlines(file)
  lines = lines.map do |line|
    if line =~ /require.*spec_helper/
      "require 'spec/spec_helper'\n"
    else
      line
    end
  end
  File.open(file,'w'){|f| f.write lines.join('') }
end

Run: ruby unify_spec_helper.rb