Martin PlÃ¶ger

[Ruby] On Language Selection

2010-08-27T14:35:45-07:00

I'd also put it in a helper (putting logic directly in the view isn't very nice to maintain). I would not set the html_options-hash with an empty class though... IMHO

BTW: if/unless expression can be put in parentheses and used as a parameter in method calls. Also have a look at the link_to_if and link_to_unless methods...

def locale_links
  [:pl, :en].map { |locale| link_to locale.to_s.upcase, {:locale => locale}, (:class => :language_selected if I18n.locale == locale)}.join ' | '
end

[Ruby] On How to make it more idiomatic?

2010-08-16T17:39:06-07:00

merge! is more efficient than merge (creates copies of the old hash). Just a tiny change...

array.inject({}) { |hash, key| hash.merge! key => func(key) }

[Ruby] On Calculate sum of items in array of hashes

2010-08-16T17:30:00-07:00

You don't need to pass the zero to inject. It then uses the first value of items for the initial value of "memo" (this is okay when adding the values). And you don't need to prefix items with self (a matter of taste).
Another thing is the double usage of "sum" for the block-variable and the result (it works because the outer variable is not initialized till the block finishes. If it was initialized before the block the behaviour depends on your Ruby-version 1.8 vs. 1.9).

sum = items.inject { |memo, item| memo + item.fragments.count }

[Ruby] On better way?

2010-07-22T07:32:39-07:00

@Adam: you call the block even if session[:pos_activation] evaluates to false unlike the original code. (Don't know if it matters or has side-effects)

def is_pos_activation?
  return yield if block_given? && session[:pos_activation]
  session[:pos_activation]
end

#OR

def is_pos_activation?
  (block_given? && session[:pos_activation]) ? yield : session[:pos_activation]
end

#OR

def is_pos_activation?
  session[:pos_activation] && (block_given? ? yield : true)
end

[Ruby] On how to refactor tricky logic involving consecutive sets?

2010-06-08T16:55:21-07:00

Hope, I understood what you meant (text not code):
10 => 10
20 => 20
30 => 30
40 => 10
50 => 20
...
Everything else (not a multiple of ten and <= zero) => 0

def check_win_streak streak
  return if streak % 10 != 0 || streak <= 0
  award_streak_badge [10, 20, 30][streak / 10 % 3 - 1]
end

[Ruby] On Generate post query for array

2010-06-01T14:58:18-07:00

Rails has a Hash#to_param-method

{ :param_one => 'foo', :param_two => 'bar' }.to_param

[Ruby] On I'm having trouble thinking in Ruby today.

2010-05-27T18:05:57-07:00

text =
"75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23"

# convert this text into an array of Fixnum arrays (this is Ruby)
rows = text.lines.map { |line| line.split.map &:to_i }.reverse

# start at the bottom of the pyramid and reduce it to a max
# empty Array is just fine, because the 1st row is not "maxed" anyway
max = rows.inject [] do |maxes, row|
  # add the elements of the maxes array to rows
  maxes.each.with_index { |max, index| row[index] += max }
  # make the next maxes array from pairs of 
  row.length > 1 ? row.each_cons(2).map(&:max) : row
end

puts max

[Ruby] On HTML query string

2010-04-29T04:44:45-07:00

Hash#map or Hash#collect works fine for that.

b = {:a => 'option1', :b => 'option2' }
b.map { |key, value| "#{key}=#{value}" }.join '&'

[Ruby] On Can I do this while loop in a better way ?

2010-04-26T06:50:01-07:00

I'm not quite satisfied with the indexes inside the #collect-method. But I think this should be resolved by improving the scraping of the html-code before the loop, not by the loop later on.

require 'rubygems'
require 'hpricot'
require 'open-uri'

doc = Hpricot(open('http://www.mpi.mb.ca/salvage/auction.asp?salenm=1694'))

cars = doc.search("tr > td > font").collect { |i| i.inner_html }

car_array = cars.each_slice(7).collect do |car|
  :num => car[0], :year => car[1],
  :make_model => car[2], vin: => car[3]
  :engine => car[4], :status => car[5],
  :km => car[6]
end

[Ruby] On Exception Handling in Ruby

2010-03-21T21:43:07-07:00

I just recycled Yury's great refactoring and used Array instead of hashes. Hope it is not less readable.

mappings = ['body', 1], ['height', 2], ['status', 7], ['country', 8, 1], ['zip', 9], ['location', 7]
mappings.each do |key, content_index, regexp_index| 
  data[key] = content[content_index].split(/\W{2,}/)[regexp_index || 0].strip rescue 'null'
end

[Ruby] On Ruby Hash Extraction Using Regex on Key

2010-03-08T20:53:03-08:00

@mxcl: Seems to be the most succinct and readable solution... except: you can get rid of the braces around the block-arguments. Since #collect on a hash returns two args they will be assigned correcly. And call #map (which is shorter ;-)):

attributes.map { |key, value| "#{$1}.#{value}" if key =~ /^svc_(\w{2})_id$/ }.compact

[Ruby] On Creating a binary file with Bindata gem

2010-03-05T20:51:58-08:00

I don't know much about binary-files. Hope, my solution works and is not too cryptic.
I put each Type and the corresponding data in an Array. So I can call the #new-method and hand in the value at the end.
Hope this gives rise to some more succinct and more readable solutions... I don't know BinData at all.

BTW: You don't need to assign and reassign the obj-variable each time.

File.open 'binary.bin', 'wb' do |file|
  b = BinData
  head = b::String, 'Binary file start-point', b::Uint32be, 0, b::Bit16,0, b::Uint24be, @fragments.size
  data = @fragments.collect { |f| [b::Uint8be, f.encoding, b::Uint8be, f.atype, b::String, f.content] }.flatten
  (head + data).each_slice(2) {|type, value| type.new(:initial_value => value).write file }
end

[Ruby] On Nested Hash from delimiter-separated String

2010-03-05T14:14:48-08:00

@mxcl, @Devin: I fiddled with #inject, too, but I got it wrong. Great solutions!
@mxcl: You don't have to assign to rv in the inject-block => even shorter: string.split('.').reverse.inject(value) { |rv, e| { e => rv } }

[Ruby] On Nested Hash from delimiter-separated String

2010-03-04T22:30:40-08:00

Use recursion on a recursive problem...

def hash_from_string string, value
  if key = string[/^([^.]+)/]
    {key => hash_from_string(string.gsub(/^[^.]+\.?/, ''), value)}
  else 
    value
  end
end

#Or shorter (but more cryptic) with the ?-operator

def hash_from_string string, value
  (key = string[/^([^.]+)/]) ? {key => hash_from_string(string.gsub(/^[^.]+\.?/, ''), value)} : value
end

p hash_from_string 'some.dot.separated.list', 'value'

[Ruby] On Function to remove consistent indentation from multiline string

2010-03-04T21:36:50-08:00

You could also use ONLY a RegEx (no need to define an 'indent' variable like Serguei did).
steenslag's and Serguei's solution do not replace the three dots '...' or did I get it wrong? Otherwise Serguei's solution is pretty fine, except that you could get rid of the temp-variable (just remove the 'length'-method-call in my example)

class String
  def squish
    self.gsub(/^.{#{self[/^\s+/].length}}/, '')
  end
end

p <<-EOS.squish
   hi
...my friend over
   there
   EOS
   
# => "hi\nmy friend over\nthere\n"

[Ruby] On Generate Days of a Year

2010-02-28T00:17:40-08:00

I'mÂ usingÂ #injectÂ toÂ buildÂ anÂ Array.Â ThatÂ wayÂ youÂ couldÂ useÂ #compactÂ toÂ removeÂ theÂ emptyÂ linesÂ (that's why I use nil instead of '') beforeÂ callingÂ #puts.
BTW:Â There'sÂ aÂ leadingÂ emptyÂ lineÂ beforeÂ theÂ month-nameÂ onÂ theÂ firstÂ dayÂ ofÂ eachÂ monthÂ (shouldÂ beÂ removedÂ maybe,Â butÂ itÂ wasÂ alsoÂ thereÂ inÂ yourÂ initialÂ code...Â refactoringsÂ don'tÂ changeÂ behaviourÂ ;-))

require 'date'
puts((Date.today..Date.today>>12).inject([]) do |m, d|
  d.day == 1 ? m.push(nil, d.strftime('%b'), nil) : (m << nil if d.wday == 1)
  m << d.strftime('%a %m.%d')
end)

[Ruby] On Fizz Buzz

2010-01-18T21:13:06-08:00

You could also use 15 as the Least common multiple of 3 and 5:

puts (1..100).map { |n| [:fizzbuzz][n%15] || [:fizz][n%3] || [:buzz][n%5] || n }

[Ruby] On Fizz Buzz

2010-01-18T20:40:56-08:00

puts (1..100).map { |n| ['fizzbuzz'][n%3+n%5] || ['fizz'][n%3] || ['buzz'][n%5] || n }

[Ruby] On Fizz Buzz

2010-01-16T12:35:18-08:00

def fizzbuzz max
  (1..max).map do |n|
    s = ['fizz'][n%3].to_s + ['buzz'][n%5].to_s
    s.empty? ? n.to_s : s
  end
end

puts fizzbuzz(100)

[Ruby] On Incrementing an attribute

2009-09-30T09:56:14-07:00

To simply increment an attribute you could use #increment or #increment! (uses the setter).
The submitted code was not so ugly to me, but you could shorten it a bit by using the if-modifier.
You should access the AdvertisementHashes through the scope of the advertisement_hashes-association

def increment_clicks!(hash_string)
  self.increment :clicks if (hash = self.advertisement_hashes.find_by_hash_string(hash_string)) && hash.destroy           # If you want to destroy the object
  # self.increment :clicks if self.advertisement_hashes.delete self.advertisement_hashes.find_by_hash_string(hash_string) # Otherwise
end

[Ruby] On Determine layout

2009-09-14T12:15:26-07:00

Not that short, but IMHO more readable

def determine_layout
  case params[:action]
    when 'index', 'show', 'edit', 'update' then 'application'
    else                                        'sessions'
  end
end

[Ruby] On ungliness and long too

2009-09-11T09:16:11-07:00

I just updated my solution and changed the order of the Regexes so that it first checks for /female/ and if it doesn't match checks for /male/. @Muke: Thanks for the hint!

#...
case name
           when /female/ then 'Female Dorm'
           when /male/   then 'Male Dorm'
#...

[Ruby] On ungliness and long too

2009-09-10T14:31:18-07:00

Another way might be a mapping-table or a hash which maps the name-parts to the matching results (size, type) and you iterate over the table/hash-keys and check if they match and then take the results.
But sometimes this might be to cryptic for so few cases:

mapping = {'double' => ['Double Bed', 2], 'twin' => ['Twin Bed', 2], 'single' => ['Single Bed', 1], 'female' => 'Female Dorm', ... }

type, size = mapping.find { |k, v| name.include? k }
size ||= name[/[0-9]+/] || 1
priv, ensuite = name =~ /private/ ? 1 : 0, name =~ /ensuite/ ? 1 : 0

name = name.gsub(/(dorm|male|female|double|single|beds|bed|private|ensuite|twin|[\d\(\)*])/,'').squeeze(' ')

puts "Name: #{name}, Size: #{size}, #{type}, #{priv}, #{ensuite}"

[Ruby] On ungliness and long too

2009-09-10T14:05:49-07:00

stuff.each do |name|
  name = name.downcase
  
  #size
  size = case name
           when /double|twin/ then 2
           when /single/      then 1
           else name[/[0-9]+/] || 1 # Set size as a last resort to 1 instead of nil
         end

  #type
  type = case name
           when /female/ then 'Female Dorm'
           when /male/   then 'Male Dorm'
           when /double/ then 'Double Bed'
           when /twin/   then 'Twin Bed'
           when /single/ then 'Single Bed'
           else               'Mixed Dorm'
         end

  #You don't need to return Strings here like you did: '1' => #{x} calls x.to_s on it  
  priv, ensuite = name =~ /private/ ? 1 : 0, name =~ /ensuite/ ? 1 : 0
  #If boolean results (true/false) are okay: priv, ensuite = %w(private ensuite).map { |x| name.include? x }
  
  #What do you exactly want with that: [\d\(\)*???
  name = name.gsub(/(dorm|male|female|double|single|beds|bed|private|ensuite|twin|[\d\(\)*])/,'').squeeze(' ')
  
  puts "Name: #{name}, Size: #{size}, #{type}, #{priv}, #{ensuite}"
end

[Ruby] On Remove element from array

2009-09-03T12:27:40-07:00

tmp = reply.case.users.map(&:email)
tmp.delete(reply.created_by.email)
tmp.join(',')           #ATTENTION DEAD CODE!!! DON'T NEED THAT tmp is NOT changed by this and the result is not used by you. result = tmp.join(',')...

@recipients  = "#{tmp}" # #{tmp} does a tmp.to_s. You could do @recipients = tmp.join(',') otherwise

#======>Refactoring 1:

mails = reply.case.users.map(&:email)
@recipients = mails.reject { |e| e == reply.created_by.email }.join(',')

#======>Refactoring 2:
#If reply.created_by is included in reply.case.users:

@recipients = reply.case.users.reject { |u| u == reply.created_by }.map(&:email).join(',')
#OR
@recipients = (reply.case.users - [reply.created_by]).map(&:email).join(',')