Yannis Kolovos: August 2014

Wednesday, 20 August 2014

παωτοοο

	# χρόνος που λεπτό δε χάνει
	# πέρασε με σενα Johnny k sunny
	# το ονομα σου αυτό το καλλιτεχνικό
	# μα εγω όλο σου λέω παωτοοο
	# κ εμένα λες μαρδέλλη
	# η κοτόπουλο, η μωρελι
	# το σουβλάκι σου αρέσει
	# μα στα χέρια σου αν πέσει
	# συνταγη σαν της μαμάς
	# θα τη φτιάξεις μονομιάς
	# οτι φτιάξεις θα το φάω
	# και οταν μονη περπατάω
	# και τα παπουτσια μου χαλάω
	# καποιο αστειο που χεις πει
	# στο μυαλό μου θα μου ρθει
	# κ οταν το δικό σου τρέχει με χιλιόμετρα πολλά
	# κάποια ιδέα θα κατεβαζεις κ θα κλαις από χαρα
	# θα γελάω κ θα σαι πάντα το καλο μου το σουβλάκι
	# ειναι που έσβησα κεράκι
	# απο τουρτα σαν μουστάκι

view raw gistfile1.rb hosted with ❤ by GitHub

Wednesday, 13 August 2014

extract_options

	def options(*args)
	args.extract_options!
	end

	options(1, 2) # => {}
	options(1, 2, :a => :b) # => {:a=>:b}



	# Use args with the splat operation to allow
	# an unlimited number of parameters
	def my_method(*args)
	options = args.extract_options!
	puts "Arguments: #{args.inspect}"
	puts "Options: #{options.inspect}"
	end

	my_method(1, 2)
	# Arguments: [1, 2]
	# Options: {}

	my_method(1, 2, :a => :b)
	# Arguments: [1, 2]
	# Options: {:a=>:b}



	#http://simonecarletti.com/blog/2009/09/inside-ruby-on-rails-extract_options-from-arrays/

view raw gistfile1.rb hosted with ❤ by GitHub

Monday, 11 August 2014

Collection Proxy

	require "delegate"

	class CollectionProxy
	def products
	@products \|\|= HasManyAssociation.new([])
	@products.associated_class \|\|= Product
	@products
	end
	end

	class Product
	def initialize(attributes)
	@attributes = attributes
	end

	attr_reader :attributes

	def name
	attributes[:name]
	end
	end


	# -----------------------------------------------------------
	# With DelegateClass
	# -----------------------------------------------------------
	class HasManyAssociation < DelegateClass(Array)
	attr_accessor :associated_class

	def initialize(array)
	super(array)
	end

	def create(params)
	self << associated_class.new(params)
	end
	end

	proxy = CollectionProxy.new
	products = proxy.products
	products.create(:name => 'products one')
	products.create(:name => 'products two')
	p products[0].name
	p products[1].name
	p products.map { \|q\| q.name }
	# -----------------------------------------------------------
	# with method_missing
	# -----------------------------------------------------------
	class HasManyAssociation < BasicObject
	attr_accessor :associated_class

	def initialize(array)
	@array = array
	end

	def create(params)
	self << associated_class.new(params)
	end

	def method_missing(*a, &b)
	@array.send(*a, &b)
	end
	end

	proxy = CollectionProxy.new
	products = proxy.products
	products.create(:name => 'products one')
	products.create(:name => 'products two')

	p products.map { \|q\| q.name }

view raw gistfile1.rb hosted with ❤ by GitHub

http://blog.rubybestpractices.com/posts/gregory/060-issue-26-structural-design-patterns.html

Proxy

A Proxy is any object that acts as a drop-in replacement object that does a bit of work and then delegates to some other underlying object. This is another pattern that’s easy to recognize for Rails developers, because it is used extensively in ActiveRecord associations support. The following example shows a typical interaction between a base model and one of its associations.

view plaincopy to clipboardprint?
quiz = Quiz.first  
quiz.questions.class #=> Array  
  
quiz.questions.count #=> 10  
  
quiz.questions.create(:question_text => "Who is the creator of Ruby?",  
                      :answer        => "Matz")  
  
quiz.questions.count #=> 11  
  
quiz.questions[-1].answer #=> "Matz"   

While the questions association claims to be an array, it also provides some of the common helpers found in ActiveRecord::Base. If we stick to the core idea and ignore some of the Rails specific details, creating such an association proxy is fairly easy to do using Ruby’s delegate standard library. The code below more or less does the trick.

view plaincopy to clipboardprint?
require "delegate"  
  
class Quiz  
  def questions  
    @questions                  ||= HasManyAssociation.new([])  
    @questions.associated_class ||= Question  
  
    @questions  
  end  
end  
  
class Question  
  def initialize(params)  
    @params = params  
  end  
  
  attr_reader :params  
  
  def answer  
    params[:answer]  
  end  
end  
  
class HasManyAssociation < DelegateClass(Array)  
  attr_accessor :associated_class  
  
  def initialize(array)  
    super(array)  
  end  
  
  def create(params)  
    self << associated_class.new(params)  
  end  
end  
  
quiz = Quiz.new  
  
# grab the proxy object  
questions = quiz.questions  
  
  
# use custom create() method on proxy object  
  
questions.create(:question_text => "Who is the creator of Ruby?",  
                 :answer        => "Matz")  
questions.create(:question_text => "Who is the creator of Perl?",  
                 :answer        => "Larry Wall")  
  
  
# use array like behavior on proxy object  
  
p questions[0].answer #=> "Matz"  
p questions[1].answer #=> "Larry Wall"  
p questions.map { |q| q.answer }.join(", ") #=> "Matz, Larry Wall"  

Interestingly enough, while Ruby provides a standard library for building Proxy objects, most people tend to implement them in a different way, through the use of an explicitmethod_missing() hook on a blank slate object such as Ruby 1.9’s BasicObject. For example, we could have written our HasManyAssociation code in the manner shown below and things would still work as expected.

view plaincopy to clipboardprint?
class HasManyAssociation < BasicObject  
  attr_accessor :associated_class  
  
  def initialize(array)  
    @array = array  
  end  
  
  def create(params)  
    self << associated_class.new(params)  
  end  
  
  def method_missing(*a, &b)  
    @array.send(*a, &b)  
  end  
end  

Without looking at the source, I’m almost sure that Rails does something similar to this, because doing some_association.class returns Array rather than the name of the proxy object. This is the only noticeable difference on the surface between this approach and the DelegateClass approach.

Personally, I’ve written proxies in both ways, and I tend to prefer the DelegateClass()approach slightly, simply because it’s more explicit and doesn’t require me to explicitly define amethod_missing() hook. But on the other hand, we can see that rolling your own proxy implementation is trivial in Ruby, and some may prefer the self contained nature of doing the delegation work yourself. It’d be interesting to hear what readers have to say on this topic, so please feel free to post to the mailing list if you prefer one approach over the other.