What RVM? I must be out of mind.

But, hey, RVM downloads ruby source code and installs it on your machine. The only difference is that I have got the ruby source checked-out on my machine and I want to use that as the source. And yes, RVM is awesome. I have spoken to Wayne (via IRC) and the man is an absolute genius, very polite and helpful.

So, somehow, I need to accomplish the following:

• Hey RVM, don’t download the ruby source.
• Here’s the location of the ruby source, use that and install it.
• Voila!

But, how do I do that? I started looking at RVM source code and I am not an expert at bash scripting, so I figured why not just mail RVM mailing list. I got the following helpful response from Micheal Papis.

it's not yet supported to use sources/rubies provided by user, but it
will be in rvm 2.0

as for using it now, you could use $rvm_path/src - and provide your
sources there ... not sure how it will work, you have to experiment a
bit

That clue was enough for me and like he said, I experimented a little bit. When you run something like:

rvm install ruby-1.9.2

RVM downloads the source code into $rvm_path/repos, moves it over to $rvm_path/src and then does the configure, compile dance. I created a symlink in $rvm_path/repos pointing at the local ruby git repository on my machine. And, then I ran the install command. Here’s the output I get:

~/.rvm/src$ rvm install ruby-head
Installing Ruby from source to: /Users/andhapp/.rvm/rubies/ruby-head, this may take a while depending on your cpu(s)...

ruby-head - #fetching 
HEAD is now at 02035ba Merge branch 'trunk' of git://github.com/ruby/ruby into trunk

From github.com:andhapp/ruby
 * branch            trunk      -> FETCH_HEAD
Already up-to-date.
Copying from repo to src path...
ruby-head - #configuring 
ruby-head - #compiling 
ruby-head - #installing 
Retrieving rubygems-1.8.10
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  243k  100  243k    0     0   456k      0 --:--:-- --:--:-- --:--:--  540k

Extracting rubygems-1.8.10 ...
Removing old Rubygems files...
-e:1: Use RbConfig instead of obsolete and deprecated Config.
Installing rubygems-1.8.10 for ruby-head ...
Installation of rubygems completed successfully.
ruby-head - adjusting #shebangs for (gem irb erb ri rdoc testrb rake).
ruby-head - #importing default gemsets (/Users/andhapp/.rvm/gemsets/)
Install of ruby-head - #complete 

This line ‘HEAD is now at 02035ba Merge branch ‘trunk’ of git://github.com/ruby/ruby into trunk’ is the last commit message on my local ruby git repository.

This line ‘From github.com:andhapp/ruby’ reflects the fact that rvm is using my git repository and not ruby’s repository and updating the local source to the latest before installing.

I decided to call the ruby installation ruby-head. You can call it anything you fancy.

Here’s the version on my machine now:

~/.rvm/src$ rvm use ruby-head
Using /Users/andhapp/.rvm/gems/ruby-head
~/.rvm/src$ ruby -v
ruby 2.0.0dev (2011-12-03 trunk 33936) [x86_64-darwin10.8.0]

Awesome!

PS: I am sure there are other details about RVM’s installation procedure that I have missed out and Wayne or Micheal will be kind enough to enlighten me.

Now, carry out a simple exercise and see what happens. Fire up an IRB session and run the following code, one by one:

    "test".hash
    1.hash
    [].hash

And note the output after every command run. Now, exit out of IRB and start a fresh session and run the same piece of code again. This time you will see the hash values have changed completely. This might be a bit surprising but it has been implemented in Ruby 1.9 for security reasons as it avoids one from guessing hash values. I picked this up from Ruby-core ML discussion and hope you find it useful.

The method I am talking about is set_trace_func. It’s part of the Kernel class and it does what it says. Allows one to set the method tracing on a method. The following snippet explains it further. Here, we have a class, TestingSetProcFunc:

    class TestingSetProcFunc
      def traceThisMethod
        source = 1
        target = 2
      end
    end

To inject set_trace_func in, it needs to be called before the method is invoked, like this:

    
    puts "Event    File:Line                Id          Binding        Classname"
    set_trace_func proc { |event, file, line, id, binding, classname|
      printf "%8s %s:%-2d %20s %12s %8s\n", event, file, line, id, binding, classname
    }

It takes a proc with upto 6 arguments. These are the events with their brief descriptions:

• c-call (call a C-language routine)
• c-return (return from a C-language routine)
• call (call a Ruby method)
• class (start a class or module definition)
• end (finish a class or module definition)
• line (execute code on a new line)
• raise (raise an exception)
• return (return from a Ruby method).

Now, to run this we just need to call the method and look at the output:

    tracer = TestingSetProcFunc.new
    tracer.traceThisMethod

This is what the output will look like when you run it on the command line:

    
Event    File:Line                Id          Binding        Classname
c-return test.rb:11       set_trace_func #   Kernel
    line test.rb:13                      #         
  c-call test.rb:13                  new #    Class
  c-call test.rb:13           initialize # BasicObject
c-return test.rb:13           initialize # BasicObject
c-return test.rb:13                  new #    Class
    line test.rb:14                      #         
    call test.rb:2       traceThisMethod # TestingSetProcFunc
    line test.rb:3       traceThisMethod # TestingSetProcFunc
    line test.rb:4       traceThisMethod # TestingSetProcFunc
  return test.rb:5       traceThisMethod # TestingSetProcFunc    

This output gives one a good idea about the work that is happening in the background. The weird looking Binding instance is the context at that particular place in the code. I have just scratched the surface and I am sure there’s a lot one can do with this method. Have a look at the ruby’s test for set_trace_func for more useful ways of employing it.

In the meantime, have a read through and see if you spot any mistakes.

A simple code example would be:

    file = File.new("datamapper.log", "a")  

I hope my efforts are useful for anyone willing to venture into Ruby Internals.

  class SomeClass
    def some_method(some_argument = '')
      raise ArgumentError unless some_argument
    end
  end

Now, I was under the impression that if I passed in a nil into this method, for some reason some_argument will still have the default value(”) as opposed to the nil value passed in but default arguments come into play when no value is passed in for the method arguments. But I was passing in nil which is an instance of NilClass and therefore some_argument gets assigned the nil value and an exception is raised.

  some_array = [1,2,3]
  some_hash = Hash[*(some_array.collect{|v| [v,v]}.flatten)] # yields {1=>1, 2=>2, 3=>3}

Few people have asked the question behind this conversion and I just decided to break it apart and tackle it bit by bit. Our objective, again, is to convert an array to a hash. Hash’s ruby documenation tells us that a new Hash object can be created by using even number of arguments. Something similar to the following code:

  some_hash = Hash[1,1,2,2,3,3] # This creates a hash object similar to this {1=>1, 2=>2, 3=>3}

All we need to do now is convert our some_array (defined in the first code snippet) and convert it into [1,1,2,2,3,3].

It’s simple really. We take the some_array and convert it into an array’s or array like this:

  some_array = [1,2,3]
  some_array.collect{|v| [v, v]} # will yield [[1,1], [2,2], [3,3]]

Now to convert it into [1,1,2,2,3,3] we just need to flatten this array of arrays like this:

  some_array = [1,2,3]
  some_array.collect{|v| [v, v]}.flatten # will yield [1,1,2,2,3,3]

Now, all we need to do is use the splat (*) unary operator. The splat operator expands the supplied array into individual arguments which is what we need to convert array into a hash. You could also achieve the same with the following snippet:

  some_array = [1,2,3]
  some_hash = Hash[*(some_array+some_array).sort] # yields {1=>1, 2=>2, 3=>3}

I hope you can work that out yourself. I hope this little discussion helped you.

  type = (self.path.match(/\.(\w+)$/)[1] rescue "octet-stream").downcase

What do you think happens here? Its quite simple really. If the first statement (the match bit) raises and exception the second statement is executed instead.

Another way to write this would be:

  begin
    type = (self.path.match(/\.(\w+)$/)[1]).downcase
  rescue
    "octet-stream"
  end

PostgreSql

  export PATH=/usr/local/pgsql/bin:${PATH}
  gem install pg

MySql

  export PATH=/usr/local/mysql/bin:${PATH}
  gem install mysql

Also, please note that you should have postgres and mysql installed on your machine.

So, block is nothing more than bits of code within curly brackets. The concept of blocks is used excessively throughout Ruby in iterators like inject, select, map, each and so on and so forth. For example:

def example_from_a_block
  puts "Should call a block"
  yield 
  puts "Yes, I did!"
end

and invoke it like:

example_from_a_block { puts "in a block" }

But blocks do have problems. Not exactly problems, but yeah shortcoming for sure. They are not objects. So…what difference does it make if they are not objects. I don’t care man. I like them. Exactly you like blocks but you would love blocks wrapped as objects. Yes, these things do exist. They are called proc or lambda. So what is a proc then? It is basically a block but with object like features, I mean you can manipulate them and pass them around like regular objects. Cool.

To create a proc, just do:

p = Proc.new { puts "I am a proc" }

It is absolutely essential to pass a block to a proc. “p” is basically an instance of the class Proc. Run this in you irb session and confim that it is indeed an object with an object_id:

p.object_id

Hmm…two down one to go. What exactly is a proc then. proc is just a simple global method, if you will, of the Kernel module. So, you can just invoke it like this:

kernels_proc_variable = proc {|a| a + 10 }

Now, proc behaves differently in Ruby 1.8 and Ruby 1.9. In 1.8, it returns a lambda where as in 1.9 it is a synonym for Proc.new. So, please be aware of this simple yet pivotal difference. Pivotal because lambda’s and proc’s are slightly different, although on the surface they look the same. They are both instances of Proc so let us just say they are siblings. There is so much more you can do with Procs and this post has just touched the surface of it. I will discuss lambda and closures in the coming posts and then compare them.

Any variable in ruby that starts with a $ sign is a global variable. You do not need to define it. It is given to you. Great!. Now, every ruby process on a UNIX (POSIX) system gives you three file descriptors stdin(fd0), stdout(fd1) and stderr(fd2). To generalise, every process is presumed to have three file descriptors, namely, standard output, standard input and standard error to communicate to the underlying OS. Since, ruby runs as a process it would also get these three file descriptors. So, $stderr, $stdout and $stdin are basically wrappers to those file descriptors and assist us in talking to the OS. Trivial operations like print this out on the console actually employs $stdout for outputting.

What kind of objects are they? Let us go to good old irb and run some code. Run the code below:

$stdout.kind_of?(IO)

This would give you “true” which bascially means that $stdout is an IO object. IO is the main input output library in ruby. Do check out the rdoc for other exciting things you can do with it. Ok. Good that we have these file descriptors so what. I do not need to know how “puts” outputs stuff to the console. I just use it. Well, that is good but one should definitely have a good understanding of controlling where the output goes otherwise when someone asks you - “How do I redirect my output to a file instead of console?”, you would just sit there with no answer. So, let us try and find an answer to the same question so that you do not look like a fool.

As it happens, we can actually redefine the $stdout. The following code would do exactly that when run in irb:

$stdout = File.open("test.log", "w")

It basically tells $stdout to spit everything out to a file called “test.log”. That’s it. Its done. Now, when you send a mesage to puts method it would use the newly defined $stdout and do the needful. Run this code in the same irb session as above and and see what happens:

puts "I am going to the file. It is more fun than printing on the cosole."

and you would not see this printed out in the console. Go and check the file test.log but to your surprise it would not be there. So, where the heck is it? Well, what happens is it is stored in a buffer and not written to the file until the buffer gets full (I am not entirely sure about this but I am guessing that would be the case). Now, if you terminate your irb session and check test.log you would find the entire ouput there but I do not want to end the session. I want to do the work and at the same time check the output. Well, not to worry the flush method does exactly that. Run this after every puts or print:

$stdout.flush

Voila! This clears the buffer and writes everthing to the file. So, there you are now you know how to redirect the output to a file. But hang on what if I want to go back to the console in the same session. Is that possible? Ofcourse, that is possible. Remember I told you about STDOUT at the beginning well that comes to the rescue. STDOUT and $stdout point to the same IO object. You can check that by running the following code in irb:

$stdout.equal?(STDOUT) 

and this gives you true, which proves my point. So, in order to go back to the original state you can just do this in order to redefine $stdout:

$stdout = STDOUT

Simple! Now, when you do:

puts "Oh Em Gee, I am back on the console."

You will see it straight away on your console. BTW, instead of $stdout you can redefine STDOUT and redirect the output to a file but puts or print would not be bothered about it as they use $stdout which is still pointing to the console.

Now comes the most interesting bit of the whole post. Are system calles affected by the redefining of $stdout. You know system calls. Well, in ruby you can use a system method to call the underlying OS functions, for example:

system('ls -l')
system('echo Wheeee')

So, the question is what happens when you redefine the $stdout does that affect the output of these system calls. And the answer is Nope, it does not. The child processes like system would still use the existing output channel that the ruby process had in the beginning. Redefining, $stdout would not change the file descriptor. The file descriptors are still there and when we redefine $stdout we just stop using them. But the native calls to the OS will still use the console for output.

That was a long post! I hope now you are better equipped with the IO knowledge and how it all works in ruby.

class FoundANewWay
    def self.to_call_a_singleton_method
        puts "It works!"
    end
end

and you can call it like this:

FoundANewWay.to_call_a_singleton_method

or

FoundANewWay::to_call_a_singleton_method

Cool!

Both, Fixnum and Symbol, store the values and have no reference to the object. This also applies that there are no mutator methods for Fixnum and Symbol and they are immutable. So, how can we actually prove this fact. Let us do a simple experiment and I think I might have done this before but I do not want you going back and forth between posts so let us just do it again. Run the code snippet and we are going through each step:

  fixnum_1 = 3
  p fixnum_1.object_id
  fixnum_2 = 3
  p fixnum_2.object_id
  str_1 = "3"
  p str_1.object_id
  str_2 = "3"
  p str_2.object_id

You will see that both the fixnum variables have the same object_id where as with str variables they will be different. So, what does that mean? It simply means that two fixnums of same value always represent the same object instance, so instance variables for Fixnum with value 1 are shared across the system. The same is the case with Symbol.

Ok. Fine. This makes perfect sense but why should I bother with all this explanation. Well, that is a million dollar question really and the answer to that is “You can’t define singleton methods on Fixnums and Symbols”. What? Why? I know this is confusing but when in doubt think of an example.

We previously established that all the fixnum variables with same value are actually pointing to the same object instance. If let us say I want to define a singleton method on one then it would really define the singleton method on that object instance which means all the fixnum variables with same value would really share that new method you have added. Therefore, in order to cut that possibilty out one cannot define singleton methods on Fixnum, and Symbls.

Update: I have just realised that true (TrueClass), false (FalseClass) and nil (NilClass) also store the references as immediate values. And, yes there is a TrueClass, FalseClass and NilClass and true, false and nil are singleton instances of these classes.

 str =  String.new("ruby rocks")

So, we define a variable called “str”, which stores a pointer to the object created by sending “new” on “String”. Here, “String” receives the “new” message but for “String” to take any action when it receives “new” message it must have a reference to the object called String. Therefore, there must be a corresponding constant to every class in ruby. It can’t be a variable as it starts with an uppercase.

Actually, that is exactly what happens. Every class in ruby has a global constant which stores a reference to the object and is used for method invocations. So, there are two things really one is the constant named String and the other is the object named String.

class Obj
  def something
    puts "calling simple"
    @abc = 3*42
    def something
      puts "calling memoized"
      @abc
    end
    something
  end
end

o = Obj.new
o.something
o.something
o.something

The output of the code is:

calling simple
calling memoized
calling memoized
calling memoized

Let us look at the code and anaylise it. ‘o’ is an instance of ‘Obj’ class. ‘something’ is an instance method of ‘O’, therefore it can access it. The first ‘o.something’ would call the instance method defined in ‘Obj’ class. So, it prints “calling simple” and then the second ‘something’ defines a method on instance ‘o’ because inside the first ‘something’ self is same as instance ‘o’.

Now, what do you get when you do something like this:

def o.something
     puts "I am o's singleton method."
end

Yes, you get a singleton method on the instance. In this case, that’s exactly what happens. The second ‘something’ defines a singleton method on instance ‘o’. We are still in the middle of executing the first something. The last line of the first something (or the outer something) calls the method ‘something’. What the hell? Cyclic messaging!!!! Never ending loop. Yeah, but the code runs and exits gracefully.

Well, the call to ‘something’ would actually go and look for ‘something’ method and before it finds a ‘something’ method defined in the class ‘Obj’ it would find the singleton-method ‘something’ and execute that. So, what would that print. Yeah, you are right it prints “calling memoized”. The second and third calls to something will again encounter the ‘something’ singleton method and execute that and it would not bother to go and look for the something defined as an instance method in class ‘Obj’.

I know you are confused. Why would it go and look for the singleton method and not the instance method. This is the magic behind Ruby’s object model. Please head over to Ola Bini’s blog and read the article on metaprogramming. He goes into a lot more detail.

instance_eval - It creates singleton methods on the object it is invoked on. If it is invoked on a Class object then these methods become singleton methods of the class. Some people would call them “class methods” but these are simply methods in an object’s singleton class. Here’s the code:

SomeObject.instance_eval (def singleton_method; "singleton_method";end)

class_eval - It creates an instance method on the object. Simple there is nothing confusing about this. Here’s an example:

SomeObject.class_eval(def instance_method;"instance_method";end)

Now, define method when used inside either class_eval or instance_eval s immune to the usual behaviour.

Why, you may ask?

Because the documentation says so. As per the documentation “define method - Defines an instance method in the receiver”. Therefore, it does not matter if you use define_method inside class_eval or instance_eval it would always create an instance method. Now, the question to ask is - “Is there no way to define a singleton method using defne_method?”. Well, I still need to investigate that. It would probably be in an update to this post. Hope it all makes sense. Ruby metaprogramming is awesome only if you know what you are doing and to get to that stage one needs to spend countless hours metaprogramming.

"#{def x(s); puts(s.reverse); end; ('1'..'3').each{|aStr| x(aStr)} }"

This is absolutely valid.