Dotfiles are configurations files, usually with their names beginning with a dot (hidden files) and located in your home directory (~/).

The repository is: https://github.com/lucascaton/dotfiles

Check the instructions in the link above, in order to get the dotfiles.

The dotfiles are focused on the Ruby language, but there’s also Git and PostgreSQL configuration files. I’ve included files as .bash_profile, .gitconfig, .irbrc (using pry), .pryrc, .psqlrc and .rvmrc. There is also a list of ruby gems (file “default.gems”).

My vimfiles can be found at: https://github.com/lucascaton/vimfiles

I have tested it only in OSX 10.7, but it should work in any *nix without problems.

Currently, the most common URLs from Youtube are http://youtube.com and http://youtu.be:

/(?:https?:\/\/)?(?:www\.)?youtu(?:\.be|be\.com)\/(?:watch\?v=)?(\w{10,})/

This regex will match:

• http://youtube.com/watch?v=1234567890
• https://youtube.com/watch?v=1234567890
• http://www.youtube.com/watch?v=1234567890
• https://www.youtube.com/watch?v=1234567890
• http://youtu.be/1234567890
• https://youtu.be/1234567890
• http://www.youtu.be/1234567890
• https://www.youtu.be/1234567890
• http://www.youtube.com/watch?v=1234567890&feature=context&context=G2de15aaFAAAAAAAAAAA
• www.youtube.com/watch?v=1234567890
• youtube.com/watch?v=1234567890
• youtu.be/1234567890

And won’t match:

• youtube.com
• youtube.com/
• youtube.com/watch
• youtube.com/watch/
• youtu.be
• youtu.be/

:g /pattern/d

Example: If you want to remove the commented lines:

# this is a comment
def whatever
end

# this is another comment
def other_method
end

Just execute:

:g /^#.*/d

And then, your text will look like this:

def whatever
end

def other_method
end

My newest gem code2pdf is a simple and open-source tool for convert your source code to a PDF file. It can be useful if you need to licence you software.

Installation

gem install code2pdf

Usage

Open a terminal and run:

code2pdf <project path> <blacklist file>

BlackList file example:

The blacklist file must be a yaml file, as such:

:directories:
  - .git
  - db/migrate
  - doc
  - log
  - public/images
  - public/system
  - script
  - spec
  - tmp
  - vendor
:files:
  - .DS_Store
  - .eprj
  - .gitignore
  - .rspec
  - .rvmrc
  - database.yml
  - development.sqlite3
  - application.yml
  - favicon.ico
  - controls.js
  - dragdrop.js
  - effects.js
  - prototype.js
  - rails.js

PDF output example

example.pdf

Please, let me know if you liked or hated it :)

Troubleshoot: Because of the large amount of submodules, if you ever have any trouble after pulling from the repository, it will be easier to just back up your old .vim folder and just git clone a new version.

Clone this repo into your home directory either as .vim (linux/mac) or vimfiles (Windows). Such as:

git clone git://github.com/lucascaton/vimfiles.git ~/.vim

Then ‘cd’ into the repo and run this to get the snippets submodule:

git submodule init
git submodule update

Now just copy (or symlink) the .vim/vimrc file as .vimrc (Mac/Linux) or copy as _vimrc (Windows) in your home directory. In Mac and Linux, the
easiest thing to do is:

ln -s ~/.vim/vimrc ~/.vimrc

If you already have a custom .vimrc file, append the following lines to load everything else along with your personal hacks:

source ~/.vim/vimrc      "linux
source ~/vimfiles/vimrc  "windows

Project source: https://github.com/lucascaton/vimfiles

Assuming we’ve a mailer to send same information:

class Notifier < ActionMailer::Base
  default :from => 'noreply@company.com'

  def instructions(user)
    @name = user.name
    @confirmation_url = confirmation_url(user)
    mail :to => user.email, :subject => 'Instructions'
  end
end

To send an email through a method from User class:

class User
  def send_instructions
    Notifier.instructions(self).deliver
  end
end

Before test it, make sure the config/environments/test.rb file is configured as follows:

AppName::Application.configure do
  config.action_mailer.delivery_method = :test
end

This ensures that emails won’t send, but store on ActionMailer::Base.deliveries array. After, just create the tests:

spec/models/user_spec.rb

require 'spec_helper'

describe User do
  before :each do
    @user = User.make
  end

  it "sends a e-mail" do
    @user.send_instructions
    ActionMailer::Base.deliveries.last.to.should == [@user.email]
  end
end

spec/mailers/notifier_spec.rb

require 'spec_helper'

describe Notifier do
  describe 'instructions' do
    let(:user) { mock_model(User, :name => 'Lucas', :email => 'lucas@email.com') }
    let(:mail) { Notifier.instructions(user) }

    #ensure that the subject is correct
    it 'renders the subject' do
      mail.subject.should == 'Instructions'
    end

    #ensure that the receiver is correct
    it 'renders the receiver email' do
      mail.to.should == [user.email]
    end

    #ensure that the sender is correct
    it 'renders the sender email' do
      mail.from.should == ['noreply@empresa.com']
    end

    #ensure that the @name variable appears in the email body
    it 'assigns @name' do
      mail.body.encoded.should match(user.name)
    end

    #ensure that the @confirmation_url variable appears in the email body
    it 'assigns @confirmation_url' do
      mail.body.encoded.should match("http://aplication_url/#{user.id}/confirmation")
    end
  end
end

In conclusion, Rails 3 allows you to create very comprehensive tests for mailers without using plugins or gems to facilitate such tests, which were common in Rails 2.