Ben Marini

[Ruby] On apply a credit over an ordered set of tuples

2011-10-23T19:18:26-07:00

Recursion seems to fit well here.

def apply_credit(credit, tuple)
  num = tuple.shift

  if num.nil?
    [ ]
  elsif num > credit
    [ num - credit ] + tuple
  else
    [ 0 ] + apply_credit(credit - num, tuple)
  end
end

if $0 == __FILE__
  require "test/unit"

  class TestBonus < Test::Unit::TestCase
    def test_case_name
      # example: if the credit is $10 and the row amounts are ($2, $6, $5),
      # it should adjust the row amounts to ($0, $0, $3)

      assert_equal [0, 0, 3], apply_credit(10, [2, 6, 5])
    end
  end
end

[Ruby] On if/else with code duplication

2011-10-01T12:56:54-07:00

Why not let your subclasses decide what options to add?

class Animal
  def queue_event
    with_new_options do
      $options << self.options
      Event.queue self, :new_video, { :object_key => self._object_key, :object_data => self._render }
    end
  end
end

class Dog < Animal
  def options
    :Dog_options
  end
end

class Cat < Animal
  def options
    :Cat_options
  end
end

[Ruby] On Parents

2011-06-14T21:27:51-07:00

Here's one way

class Node < Struct.new(:name, :parent)
  def ancestors
    parent.nil? ? [] : [ parent ] + parent.ancestors
  end

  def to_s
    name
  end
end

progenitor          = Node.new('progenitor')
grand_grand_parent  = Node.new('grand_grand_parent', progenitor)
grand_parent        = Node.new('grand_parent', grand_grand_parent)
parent              = Node.new('parent', grand_parent)
node                = Node.new('node', parent)

puts node.ancestors.join(", ")

[Ruby] On Inject all filenames of a specific directory in one line

2011-05-24T21:22:42-07:00

FILENAMES = Dir["a/certain/dir/*"]

[Ruby] On Messy Blocks

2011-04-07T15:10:37-07:00

My progressive refactoring, final is at the bottom.

def disease_search(query)
  treatment_results = Array.new
  symptom_results = Array.new
  image_results = Array.new
  note_results = Array.new

  disease_results = Disease.search("#{query} user_id:#{current_user.id}")

  Treatment.search("#{query}").each do |treatment|
    treatment_results.push(treatment.diseases)
  end

  Symptom.search("#{query}").each do |symptom|
    symptom_results.push(symptom.disease)
  end

  Note.search("#{query}").each do |note|
    note_results.push(note.disease)
  end

  Image.search("#{query}").each do |image|
    image_results.push(image.disease)
  end

  search_results = (disease_results.concat(treatment_results).concat(symptom_results).concat(image_results).concat(note_results)).uniq
  return search_results
end

def disease_search(query)
  disease_results   = Disease.search("#{query} user_id:#{current_user.id}")
  treatment_results = Treatment.search("#{query}").map { |t| t.diseases }
  symptom_results   = Symptom.search("#{query}").map { |s| s.disease }
  note_results      = Note.search("#{query}").map { |n| n.disease }
  image_results     = Image.search("#{query}").map { |i| i.disease }

  search_results = (disease_results.concat(treatment_results).concat(symptom_results).concat(image_results).concat(note_results)).uniq
  return search_results
end

def disease_search(query)
  results  = []
  results += Disease.search("#{query} user_id:#{current_user.id}")
  results += Treatment.search("#{query}").map { |t| t.diseases }
  results += Symptom.search("#{query}").map { |s| s.disease }
  results += Note.search("#{query}").map { |n| n.disease }
  results += Image.search("#{query}").map { |i| i.disease }
  results.uniq
end

require 'set'
def disease_search(query)
  results = Set.new
  results.merge Disease.search("#{query} user_id:#{current_user.id}")
  results.merge Treatment.search("#{query}").map { |t| t.diseases }
  results.merge Symptom.search("#{query}").map { |s| s.disease }
  results.merge Note.search("#{query}").map { |n| n.disease }
  results.merge Image.search("#{query}").map { |i| i.disease }
  results
end

[Ruby] On Clear a hash of empty string values recursively

2011-03-16T05:14:04-07:00

class String
  def blank?
    self == ""
  end
end

class Hash
  def blank?
    self == {}
  end

  def remove_blanks
    inject({}) do |mem,(key,val)|
      case val
      when String
        mem[key] = val
      when Hash
        mem[key] = val.remove_blanks
      end unless val.blank?

      mem
    end
  end
end

require "test/unit"

class TestHash < Test::Unit::TestCase
  def test_hash
    h = {
      'a' => '',
      'b' => {
        'c' => '',
        'd' => 'e'
      }
    }

    expected = { 'b' => { 'd' => 'e' } }
    assert_equal expected, h.remove_blanks
  end
end

[Ruby] On Event: set end time based on length

2010-11-29T02:32:39-08:00

My thought is the interface to this class is confusing...try to simplify it by imposing some restrictions.

# * Create a factory method for creating events. Make length required.
# * Require start and end times for persistence.
# * Don't allow length to be changed. It is confusing...should the start time
#   or end time change when length changes?
class Event < ActiveRecord::Base
  validates_presence_of :start_time, :end_time

  def self.from_start_time_and_length(start_time, length)
    self.start_time = start_time
    self.end_time   = start_time + length.minutes
  end

  def length
    @length ||= ( self.end_time - self.start_time ) / 60
  end
end

[Ruby] On Triangles

2010-10-18T15:36:17-07:00

class TriangleError < StandardError; end

def triangle(a, b, c)
  if [a,b,c].any? { |e| e <= 0 }
    raise TriangleError, "Wrong length"
  end

  if [ [a,b+c], [b,a+c], [c,a+b] ].any? { |(side, sum)| side >= sum }
    raise TriangleError, "Too small"
  end

  case [a,b,c].uniq.length
  when 1 then :equilateral
  when 2 then :isosceles
  else;       :scalene
  end
end

[Ruby] On instance extending problem

2010-07-18T20:56:10-07:00

String is not outputting the way you want because `#to_yaml_properties` (called in `String#to_yaml`) is detecting the `prefix` accessor. Here is one way around that...

module Actions
  attr_accessor :prefix

  def to_yaml
    prefix + super
  end

  def to_yaml_style
    :inline
  end

  def to_yaml_properties
    []
  end
end # Actions

[Ruby] On group objects in array

2010-03-31T00:27:50-07:00

You don't need to do a select inside the group_by. The way #group_by works is it groups based on the return value of the block you pass it. Try it this way and see how it performs:

res = arr.group_by { |f| [f.status_id, f.profile_id] }.values

[Ruby] On group objects in array

2010-03-29T15:13:38-07:00

#group_by does what you need, you just need to grab the values of the hash afterward

require 'rubygems'
require 'active_support'
Foo = Struct.new(:id, :status_id, :profile_id)
arr = [Foo.new(1,2,3),Foo.new(2,2,3),Foo.new(3,1,3)]
res = arr.group_by(&:status_id).values
p res

[Ruby] On Symplify few loops

2010-02-03T16:09:53-08:00

Here's my functional version: http://gist.github.com/293713

[Ruby] On Symplify few loops

2010-02-03T16:09:09-08:00

Here's my functional version, with some test code.

module Bitmap
  def self.bgr_to_rgba(raw_bgr_array, width, height, new_dimension)
    width_padding  = new_dimension - width
    height_padding = new_dimension - height

    # First convert to array of Pixel::BGR objects
    raw_bgr_array.enum_for(:each_slice, 3).map { |a| Pixel::BGR.new(*a) }.
      reverse. # Reverse it
      map { |bgr| bgr.to_rgba }. # Map to array of Pixel::RGBA objects
      enum_for(:each_slice, width).inject([]) { |memo, row| memo << row }. # Create a 2d array based on width
      map { |row|
        row.concat( [Pixel::RGBA.blank] * width_padding )
      }.concat( [ [Pixel::RGBA.blank] * new_dimension ] * height_padding ). # Change dimensions of 2d array, adding blanks
      flatten.map { |rgba| rgba.to_a }.flatten # Flatten everything back into an array of integers
  end

  module Pixel
    class RGBA < Struct.new(:red, :green, :blue, :alpha)
      def self.blank
        new(0,0,0,0)
      end

      def to_a
        [red, green, blue, alpha]
      end
    end

    class BGR < Struct.new(:blue, :green, :red)
      def to_rgba
        RGBA.new(red, green, blue, 255)
      end
    end
  end
end

if __FILE__ == $0
  require "test/unit"
  class TestBgrToRgba < Test::Unit::TestCase
    def test_bgr_to_rgba
      width     = 2
      height    = 3
      real_size = 4 # closest power of 2

      data = [
        255, 0, 0, # 1st pixel, blue (third row)
        255, 0, 0, # 2st pixel, blue
        
        0, 255, 0, # 3nd pixel, green (second row)
        0, 255, 0, # 4nd pixel, green
        
        0, 0, 255, # 5rd pixel, red (first row)
        0, 0, 255, # 6rd pixel, red
      ]

      corrected = [
        255, 0, 0, 255, # 1st pixel, red (first row)
        255, 0, 0, 255, # 2st pixel, red
        0, 0, 0, 0,     # Empty
        0, 0, 0, 0,     # Empty
        
        0, 255, 0, 255, # 3nd pixel, green (second row)
        0, 255, 0, 255, # 4nd pixel, green
        0, 0, 0, 0,     # Empty
        0, 0, 0, 0,     # Empty
        
        0, 0, 255, 255, # 5rd pixel, blue (third row)
        0, 0, 255, 255, # 6rd pixel, blue
        0, 0, 0, 0,     # Empty
        0, 0, 0, 0,     # Empty
        
        0, 0, 0, 0,     # Empty (last row)
        0, 0, 0, 0,     # Empty
        0, 0, 0, 0,     # Empty
        0, 0, 0, 0      # Empty
      ]

      result = Bitmap.bgr_to_rgba(data, width, height, real_size)
      assert_equal corrected, result
    end
  end
end

[Ruby] On Symplify few loops

2010-01-31T20:33:21-08:00

I'd like to help out, but I can't quite figure out what your code snippet is doing. Can you provide a more complete code snippet? For instance, define `height`, `width`, `real_size`, `data`, and `corrected`?

[PHP] On How should I optimize this for speed?

2009-12-08T08:13:42-08:00

Your benchmarking code is benchmarking more than just your Collection class. It's also benchmarking microtime() and more importantly, mt_rand(). You should isolate your code in the benchmark. With the code below, I was getting roughly 97,951 writes per second on my 2.4Ghz MacBook. I got was able to speed that up 150% (150,428 writes per sec) by replacing your while loops with foreach loops in the data function.

<?php
  // Benchmarks for writes and reads, separated.
  $times = 10000;
  $set   = new Collection();
  $start = microtime(true);
  for ($i=0; $i < $times; $i++) { 
    $set->data('random.numbers.put.in.a.really.deeply.nested.array', 5); // Write
  }
  $diff = microtime(true) - $start;
  echo "Writes, long key\n";
  echo "$times writes in $diff\n";
  echo $times / $diff . " writes/sec\n\n";

  $times = 10000;
  $set   = new Collection();
  $set->data('random.numbers.put.in.a.really.deeply.nested.array', 5);
  $start = microtime(true);
  for ($i=0; $i < $times; $i++) { 
    $set->data('random.numbers.put.in.a.really.deeply.nested.array'); // Write
  }
  $diff = microtime(true) - $start;
  echo "Reads, long key\n";
  echo "$times reads in $diff\n";
  echo $times / $diff . " reads/sec\n\n";

  // Data function with while loops replaced with foreach loops

    public function data($key,$value=null) {
      $keys = explode('.', $key);
      $ptr  = &$this->data;
      if ( !is_null($value) ) {
        foreach ($keys as $key) {
          if ( !isset($ptr[$key]) ) $ptr[$key] = array();
          $ptr = &$ptr[$key];
        }

        $ptr[] = $value;
        return true;
      } else {
        foreach ($keys as $key) {
          $ptr = &$ptr[$key];
        }
        return array_shift($ptr);
      }
    }

[Ruby] On Can this be less clunky?

2009-11-30T17:26:43-08:00

I'm with Daniel, the source of the problem is the confusing hash, which is
hard to work with. Here's a more OO approach, similar to Daniel's.

class Channel < Struct.new(:name, :pages)
end

class Page < Struct.new(:name, :items)
  def dash_count
    items.select { |i| i.dash? }.size
  end
end

class Item < Struct.new(:name, :type)
  def dash?
    type == "dash"
  end
end

items    = [ Item.new("X", "dash"), Item.new("Y", "dash"), Item.new("Z", "non-dash") ]
pages    = [ Page.new(:Test, items) ]
channels = [ Channel.new("PRO", pages) ]

if logger.debug?
  channels.each do |channel|
    logger.debug "Pages for #{channel.name} channel:"

    channel.pages.each do |page|
      logger.debug "- *#{page.name}* with #{page.dash_count} dashboard(s)"
    end
  end
end

[PHP] On An easy one: traversing through an array

2009-11-16T17:15:01-08:00

I might be tempted to do something like this.

<?php
  // $id = Request::get("id");
  class Request {
    public static function get($key, $default=null) {
      return array_key_exists($key, $_GET) ? $_GET[$key] : $default;
    }
    
    public static function post() {
      // ...
    }
  }

[Ruby] On lexer

2009-11-13T21:31:39-08:00

Sounds like something you implement nicely in Ruby 1.9 using a lazy enumerator:
http://www.michaelharrison.ws/weblog/?p=163

[Ruby] On JRuby : including Java classes in a module

2009-11-07T00:08:38-08:00

Does this not work?

module Prototype
  klasses = { 
    "com.utils"  => [ 'guimodel.PresentationEntry', 'guimodel.PresentationGroup'],
    "com.system" => [ 'model.ContentItem', 'model.ContentClass' ] 
  }

  klasses.each_pair { |prefix, klass| include_class("#{prefix}.#{klass}") }
end

[Ruby] On Fading from one color to another

2009-11-04T21:15:57-08:00

I think this does what you need...

def color_range(start,finish, intervals)
  range = Range.new(start[1..-1].hex, finish[1..-1].hex)
  incr  = (range.last - range.first) / intervals
  range.step(incr) { |hex| yield "##{hex.to_s(16)}" }
end

color_range('#204a87', '#729fcf', 8) { |color| puts color }

[PHP] On Determine whether it's day or night at a latlong

2009-11-03T03:10:58-08:00

First off, your $latitude and $longitude are not defined, so no point in including those. Seemed like most of the params you were passing to date_sunrise() and date_sunset() were or could be handled by defaulting values in the ini or via ini_set(), unless you needed them to be variable. As for the if/else logic, just say it out loud and it makes perfect sense. "If the current time is after the sunrise and before the sunset, then it's daytime. Otherwise, it's nightime". I thought it made more sense for this function to return a boolean, to give it more reusability. Oh yeah, and using a timestamp as a return value for date_sunrise/set() makes it a lot easier to do comparisons with the current time.

<?php
  date_default_timezone_set("GMT");

  // Returns true if it is daytime, false otherwise
  function daytime() {
    $now     = time();
    $sunrise = date_sunrise($now, SUNFUNCS_RET_TIMESTAMP);
    $sunset  = date_sunset( $now, SUNFUNCS_RET_TIMESTAMP);
    return ($sunrise < $now && $now < $sunset);
  }

  echo daytime() ? "day" : "night";

[Ruby] On Adding an object with accessor to class instance

2009-10-11T20:50:45-07:00

Jim Weirich's builder gem for xml is a really good example of a DSL that uses method_missing.

[Ruby] On Adding an object with accessor to class instance

2009-10-08T06:57:34-07:00

Is the only point of ObjectContainer to provide a different syntax for accessing it's elements? You could also use a Hash with your "MyObject".

c = {}
c[:label1] = MyObject.new("label1", "value1")

[Ruby] On Adding an object with accessor to class instance

2009-10-08T06:53:52-07:00

Seems to me like you might as well just use the built-in Hash.

# Method 1 (Using ObjectContainer)
obj = MyObject.new("label", "value")
container = ObjectContainer.new
container << obj
puts "#{container.label}"

# Method 2 (using built-in Hash class)
container = {}
container[:label] = "value"
puts "#{container[:label]}"

[Ruby] On Pagination total page count

2009-10-07T06:44:07-07:00

A variation that's arguably less readable.

@total_pages = total.quo(per_page).ceil