michiel

[Ruby] On Print out the Regex Capture

2007-11-06T01:48:23-08:00

grep -o  regexp filename

[Ruby] Base 62 Encoding

2007-11-01T01:42:07-07:00

Base WHAT??? Well, 62 is the number of alphanumeric characters. Base 64 makes more sense, but nobody can agree about what the two missing characters should be.

Ruby's Numeric#to_s(base = 10) method works great, but won't accept a base above 36. Hence my implementation, which works, but is VERY VERY SLOW.

Update: Rubinius actually does support base 62, and provides the c-code that does it:

http://www.google.com/codesearch?hl=en&q=+package:%22http://code.fallingsnow.net/svn/rubinius/trunk%22+mp_toradix_nd+show:8_qyRkJt6rs:_xHLAYhCNJI:gMCPZeygnhk&sa=N&cd=2&ct=rc&cs_p=http://code.fallingsnow.net/svn/rubinius/trunk&cs_f=shotgun/external_libs/libtommath/bn_mp_toradix_nd.c#first

Seems like my algorithm is plenty fast, it's just Ruby being s.l.o.w.

SIXTYTWO = ('0'..'9').to_a + ('a'..'z').to_a + ('A'..'Z').to_a

def to_s_62(i)
  return '0' if i == 0
  s = ''
  while i > 0
    i,r = i.divmod(62)
    s = (SIXTYTWO[r]) + s
  end
  s
end

[Ruby] On String#to_proc (by Reginald Braithwaite)

2007-10-28T18:35:45-07:00

Ok, I've removed the nested ifs and I've introduced guards to quicky exit the method if possible. But I've made no attempt to parse the (uncommented) regular expressions, which do most of the actual work.

class String
  unless ''.respond_to?(:to_proc)
    def to_proc(&block)
      evaller = lambda {|ex| eval(ex, block && block.binding) }
      prc_templ = lambda {|prm,ex| 'Proc.new { |' + prm.join(', ') + "| #{ex} }" }
      expr = self
      sections = expr.split(/\s*->\s*/m).reverse
      return eval(sections.inject { |e, p| evaller["(" + prc_templ[p.split(/\s/), e] + ")"] }) if sections.length > 1
      return evaller[prc_templ[['_'],expr]] if expr.match(/\b_\b/)
      params = []
      if expr.match(/^\s*(?:[+*\/%&|\^\.=<>\[]|!=)/m)
        params.push('$left')
        expr = '$left' + expr
      end
      if expr.match(/[+\-*\/%&|\^\.=<>!]\s*$/m)
        params.push('$right')
        expr += '$right'
      end
      if params.empty?
        x = self.gsub(/(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|self|arguments|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/, '')
        x.scan(/([a-z_$][a-z_$\d]*)/i) {|v|  params.push(v) unless params.include?(v) }
      end
      evaller[prc_templ[params,expr]]
    end
  end
end

[Ruby] On Rubyize this : 4th edition

2007-10-24T11:15:32-07:00

Building on Mark Van Holstyn's solution, keeping the 'keep_spiders' syntax and cleaner syntax for entering bugs.

require 'rubygems'
require 'active_support'

MSG = "I am a %s and my name is %s. I have an IQ of %s and an annoyance factor of %s"

class Bug < Struct.new(:type, :desc)
  alias to_s desc
end

class Bugs < Array
  def method_missing(name, *_)
    return super unless name.to_s =~ /^keep_/
    Bugs.new(select { |bug| bug.type.to_s == name.to_s[5..-1].singularize })
  end
end

def make_bugs(bugs = Bugs.new)
  yield lambda {|*a| bugs << Bug.new(a[1], sprintf(MSG, *a)) }
end

bugs = make_bugs do |bug|
  bug["ron",    :spider,       4,  2]
  bug["don",    :spider,       2,  3]
  bug["jake",   :ant,          9,  4]
  bug["chris",  :ladybug,      2,  4]
  bug["fred",   :cockchaffer,  0,  5]
  bug["greg",   :butterfly,    2,  0]
  bug["jason",  :butterfly,    0,  2]
end

puts bugs.keep_butterflies

[Ruby] On Argument eval

2007-10-23T11:33:10-07:00

And you don't use "eval" because you don't trust the caller? What does "line_eval" do?
Also, use "scan" to break up the entire line in tokens (square brackets, commas, => and others).
You could even use something like Racc (http://i.loveruby.net/en/projects/racc/doc/) to generate a parser for you. Overkill, I know, but a nice exercise, and with only four tokens it can't be hard.

[Ruby] Combinatorial explosion with continuations

2007-10-14T10:57:52-07:00

This code tries to find all variations of an English sentence produced by contracting pronouns and modal verbs.

To see what it does, just run it, or look at the assertions at the bottom.

It's a fragment of a problem that my start-up has. I'm trying to collect all translations of a given sentence, and suddenly a previously trivial method turns out to have more than one possible answer in one edge case, and I have to go on a huge refactoring spree to accomodate that.

I'm now exploring a general solution that uses continuations. I hope this will it easier to add new rules to my code.

Can you do it cleaner? Using "amb"? Without the global variable? Shorter and without continuations? Using a list monad? Using other techniques?

$c = []
def fork_reality(*l)
  callcc {|c| $c << c }
  $c.pop if l.size <= 1
  l.shift
end

def collect_realities
  $c.last.call until $c.empty?
end

def contract_sentence(arr, index = 0, res = [])
  return res.compact.join(' ') if index == arr.size 
  skip = 1
  x = arr[index]
  nxt = arr[index+1]
  nxt2 = arr[index+2]
  r = case
  when x == 'a' && (nxt =~ /^[aeiuo]/ || nxt =~ /^hono/ || nxt =~ /^honest/ || nxt =~ /^hour/)
    'an'
  when x == 'I' && nxt == 'am'
    skip = 2
    fork_reality("I'm", "I am")
  when %w(you we they).include?(x) && %w(are have).include?(nxt) && nxt2 == 'not'
    skip = 3
    fork_reality("#{x}'#{nxt[-2,2]} not", "#{x} #{nxt}n't", "#{x} #{nxt} not")
  when %w(you we they).include?(x) && %w(are have).include?(nxt)
    skip = 3
    fork_reality("#{x}'re", "#{x} #{nxt}")
  when %w(he she it).include?(x) && %w(is has).include?(nxt) && nxt2 == 'not'
    skip = 3
    fork_reality("#{x} #{nxt}n't", "#{x} #{nxt} not")
  when %w(he she it).include?(x) && %w(is has).include?(nxt)
    skip = 2
    fork_reality("#{x}'s", "#{x} #{nxt}")
  when %w(is are).include?(x) && nxt == 'not'
    skip = 2
    fork_reality("#{x}n't", "#{x} #{nxt}")
  else
    x
  end
  contract_sentence(arr, index + skip, res + [r])
end

r = []

r << contract_sentence(%w(I am green but you are not white and Bob is not a honest man while Alice and Ina are not purple))

collect_realities

raise unless r.include? "I'm green but you aren't white and Bob isn't an honest man while Alice and Ina aren't purple"
raise unless r.include? "I'm green but you are not white and Bob is not an honest man while Alice and Ina are not purple"
raise unless r.include? "I am green but you are not white and Bob is not an honest man while Alice and Ina aren't purple"

p r

[Ruby] On Iffy

2007-10-12T01:37:47-07:00

YAML solutions break down when the text isn't static. I use procs:

# in helper 

  TIME_REMAINING_TODAY =  {
   :en => "%s of practice remaining today",
   :nl => "nog %s te oefenen vandaag",
   :de => "noch %s zu Ã¼ben heute",
   :fr => "encore %s de pratique aujourd'hui",
  }
  define_message :time_remaining_today do |time, lang|
    sprintf(TIME_REMAINING_TODAY[lang], i_distance_of_time_in_words(time, lang))
  end

# in model  (doesn't know or care about user language)
return time_remaining_today(interval)

# in controller
@msg = model.calc_time

# in view

<%= @msg[@user.lang] %>

[Ruby] On is_prime?

2007-10-07T16:28:11-07:00

Looks good, David! One nitpick is that since you know the size of the array, it's faster to initialize it with that size. I'd leave is_prime? undefined for 0 and 1.

primes = Array.new(nil, ceiling + 1)

[Ruby] On Random number generator

2007-10-05T13:43:33-07:00

You know, rand(x) doesn't return anything but numbers either - why bother doing it one character at the time?

(1..500).map {rand(10 ** 16).to_s.rjust(16,'0')}

[Ruby] On Recursively convert multidimensional structure's values to string

2007-10-05T09:31:56-07:00

In your inner loop, i == a[:hash][a[:hash].index(i)].

# Converts:
# {:hash => [{:foo => 1}, {:foo => 2}]}
# 
# To:
# {:hash => [{:foo => "1"}, {:foo => "2"}]}

a[:hash].each do |i| 
  i.each do |key,value| 
    i[key] = value.to_s
  end
end

[Ruby] On Looking for alphabetized place in array set

2007-10-04T15:47:54-07:00

The previous refactoring is great. Just let the db do the work. Staying closer to the original, it could be a lot leaner. Don't bother with breaks, just return when you've found your match. If the first child's name > than the cat_name, there's no match. If you haven't found anything after the loop, it's the last child, if there are any children.
You can you inject to keep track of 'left' - you seed it with "inject(nil)" - the last expression becomes "left" in the next iteration, and you store the final iteration in the "left" local variable.
has_many relations don't return nil - no need to check. And "unless !" is better known as "if".

Cheers,

Michiel.

def self.find_left_sibling( parent_id, cat_name )
    parent = Category.find( :first, 
                            :conditions => [ "id = ?", parent_id] )
    left = parent.children.inject(nil) do |left,child|
      return left && left.id if cat_name < child.name
      child
    end 
    left && left.id
end

[Ruby] Enforcing bounds

2007-10-04T04:55:34-07:00

Given a value and a range, I want to the value, unless it falls outside the range. In that case I want to return the lower or upper bound. Is there a more readable solution which does not involve creating new methods?

x < lower ? lower : x > upper ? upper : x

# Or should I just go this way:
# class Range; def %(x); x < first ? first : x > last ? last : x ; end ; end
# (0..5) % x

[Ruby] On Show a default value if object or field is empty?

2007-10-03T18:52:27-07:00

The original solution is fine, except for calling the block twice instead of caching the result. BTW, why test using object.nil? and not just using !object ? Do you really except false values for object?

def show_value_or_default(object, default = "-")
  return default if object.nil?
  tmp = yield(object)  
  tmp.blank? ? default : tmp 

  # or as a single expression
  # (object.nil? || (tmp = yield(object)).blank?) ? default : tmp
end

[Ruby] On is_prime?

2007-10-01T19:55:40-07:00

This is a concise implementation of Fermat's Little Theorem. But don't run it because it is really slow. You need an algorithm to calculate a^p % p without actually calculating a^p, since a == 47 and p == 100000 in this example. You can probably find it in Knuth, second volume.

class Integer
  PR = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
  def is_prime?
    PR.all? {|x| x ** self % self == x}
  end
end

# don't run

[Ruby] On is_prime?

2007-10-01T19:40:35-07:00

This is equally long, and 20% faster. Not as elegant as Fermat's Little Theorem, but I don't know how many tests you need to get acceptable accuracy.

require 'benchmark'
include Math

GC.disable

PR = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
class Integer
  def is_prime?
    return PR.include?(self) if self < 53
    PR.each {|y| return false if self % y == 0 }
    i = 53
    ss = sqrt(self).floor
    while i <= ss
      return false if self % i == 0
      i += 2
    end
    true
  end
end

# test it
primes = []
puts Benchmark.realtime{(1..100000).each{|x|primes << x if x.is_prime?}}
puts primes.size

[Ruby] On Random pronouncable password

2007-10-01T13:18:03-07:00

There is duplication in the list of consonants, and the method does uppercase too. Plus, Array should really have *pick* (rails 2.0 has it, but they call it *rand*).

class Array
  def pick
    at rand(size)
  end
end

def random_pronouncable_password(size=4)
  v = %w(a e i o u y)
  c = ('a'..'z').to_a - v - ['q'] + %w(qu ch cr fr nd ng nk nt ph pr rd sh sl sp st th tr)
  (1..size).map{[c.pick, v.pick]}.flatten.map{|x| [x,x.upcase].pick}.join('')
end