MyFunnyDev » Ruby

class variables, class instance variables and instance variables in ruby

Michał Kuklis — Wed, 13 Jan 2010 06:03:22 +0000

This was covered multiple times already. I’ve created this little snippet to remember the difference between different types of variables in ruby:

class A
  @@foo = "class variable of the class A"
  @foo = "class instance variable of the class A"
 
  def instance_method
   @foo = "instance variable of the class A"
  end
 
  def self.class_method1
    # class variables are visible to and shared by the instance and class methods
    @@foo
  end
 
  def self.class_method2
    # class instance variables are visible to and shared by the class methods
    @foo
  end	
end
 
p A.new.instance_method # instance variable of the class A
p A.class_method1 # class variable of the class A
p A.class_method2 # class instance variable of the class A
 
class B < A
  @@foo = "class variable of the class B"
  @foo = "class instance variable of the class B"
end
 
p B.class_method1 # class variable in B
# class variable in A is overwritten by one in B !!!
p A.class_method1 # class variable in B
 
p B.class_method2 # class instance variable of the class B
# class instance variable in A is NOT overwritten by one in B !!!
p A.class_method2 # class instance variable of the class A

anemone with hpricot

Michał Kuklis — Mon, 11 Jan 2010 05:06:32 +0000

Anemone is a pretty cool DSL used for web crawling. I used it with Hpricot to get a feeling for what’s possible. Below is a simple example which crawls and scrappes data from a popular polish real estate website otodom:

require 'rubygems'
require 'sanitize'
require 'anemone'
require 'open-uri'
require 'hpricot'
 
#otodom.pl
Anemone.crawl("http://otodom.pl/index.php?mod=search&act=searchResults&qid=46911208", 
{:storage => Anemone::Storage.PStore("crawl1.pstore")}) do | anemone |
 
  # filter out useless pages
  anemone.focus_crawl do |page|
   page.links.delete_if do |x|
    (x.to_s =~ /mod=search&act=searchResults&qid=/).nil? and
    (x.to_s =~ /[a-zA-Z]+-id[0-9]*\.html$/).nil?
   end
  end
 
  # process details pages
  anemone.on_pages_like(/[a-zA-Z]+-id[0-9]*\.html$/) do | page |
     doc = Hpricot(page.doc)
     price =  doc.at("//strong[@id='offerPrice']")
     location = doc.at("//dl[@class='stripeMe'] > dd")
     desc = doc.at("//div[@id='offerDesc'] > p")
     offer_no = doc.at("//div[@id='offerFoot'] p[@class='toLeft']/span/strong")
     created_at = doc.at("//div[@id='offerFoot'] p[@class='toRight']/span/strong")
     photos = doc.search("//div[@id='imageList']/p/a")
  end
end

blocks, procs and lambdas in ruby

Michał Kuklis — Wed, 18 Nov 2009 04:12:20 +0000

Nice post about block, procs and lambdas in ruby by Robert Sosinski.

ruby maxins in rails plugins

Michał Kuklis — Tue, 21 Jul 2009 01:16:46 +0000

Very often when looking at the code in rails plugins you can run into this:

module Taggable 
  def self.included(base)
    base.extend(ClassMethods)
  end
  module module ClassMethods
    #methods here
  end
end

This is a part of a bigger pattern which is shown below:

module ModuleA
  def self.included(base)
    # add class methods from ModuleB
    base.extend(ModuleB)
  end
end
 
module ModuleB
  def act_as_hello
    p "hello from module B"
  end
end
 
class ClassC
 #class body here
end
 
# include moduleA in classC
ClassC.send(:include, ModuleA)
 
class ClassD < ClassC
  act_as_hello
end
 
classD = ClassD.new

The pattern is used often when developing plugins with ActiveRecord. What we gain by inheriting from ClassC (class ClassD < ClassC) are instance methods from ModuleA. This is done by:

ClassC.send(:include, ModuleA)

Moreover since ModuleA is included in ClassC, ModuleA’s initializer def self.included(base) will be invoked at the time ModuleA is mixed with ClassC. The invocation will call base.extend(ModuleB). In this case base represents ClassC which will be extended by adding class methods from ModuleB. The ModuleA’s init method is shown again below:

def self.included(base)
  # add class methods from ModuleB to ClassC
  base.extend(ModuleB)
end

At the end our ClassD has now access to all class methods defined in ModuleB. act_as_hello will be called during ClassD initialization:

class ClassD < ClassC
  act_as_hello
end

Class and Instance Variables In Ruby

Michał Kuklis — Sun, 14 Jun 2009 04:27:11 +0000

nice post about class and instance vars in ruby.

few more ruby links

Michał Kuklis — Mon, 18 May 2009 23:24:42 +0000

going back to ruby again…

Michał Kuklis — Sat, 04 Apr 2009 18:05:00 +0000

Here are few links which helped me understand few ruby concepts:

stage deployment with capistrano and passenger

Michał Kuklis — Sat, 14 Mar 2009 22:20:36 +0000

I’m still looking around for a stage deployment setup with Capistrano.
Here are few ideas/links I found useful.

Update:
It turned out this is pretty simple with the capistrano-ext gem:

http://weblog.jamisbuck.org/2007/7/23/capistrano-multistage

set :default_stage, "development"
set :stages, %w(production testing development)
require 'capistrano/ext/multistage'

heroku

Michał Kuklis — Wed, 20 Feb 2008 04:25:18 +0000

http://heroku.com/ – awesome work…

Rails 1.1.2 + Apache2 + FCGI on Windows XP

Michał Kuklis — Wed, 12 Apr 2006 04:49:27 +0000

Setting up Rails on Windows can be pain in the butt. I spent couple hours reading posts and changing Apache and Rails configuration and finally I found WARR.

Just follow directions from this post and don’t forget to add:

LoadModule rewrite_module modules/mod_rewrite.so

to your httpd.conf file.
I had some problems after all but I created new project and everything works great!