koans_score.rb

require File.expand_path(File.dirname(__FILE__) + '/edgecase')

def triple?(dice, val)
   dice.count {|die| die == val} >= 3
end

def get_triple_bonus(dice)
  return 0 if dice.empty?
  return 350 if triple? dice, 5
  return 700 if triple? dice, 1
  return_value = 0 
  (2..6).each do |die|
    return_value = die * 100 if triple? dice, die
  end
  return return_value  
end

def score(dice)
  total = get_triple_bonus dice
  dice.each do |die|
    total += 50 if die == 5
    total += 100 if die == 1
  end
  total
end

class AboutScoringAssignment < EdgeCase::Koan
  def test_score_of_an_empty_list_is_zero
    assert_equal 0, score([])
  end

  def test_score_of_a_single_roll_of_5_is_50
    assert_equal 50, score([5])
  end

  def test_score_of_a_single_roll_of_1_is_100
    assert_equal 100, score([1])
  end

  def test_score_of_multiple_1s_and_5s_is_the_sum_of_individual_scores
    assert_equal 300, score([1,5,5,1])
  end

  def test_score_of_single_2s_3s_4s_and_6s_are_zero
    assert_equal 0, score([2,3,4,6])
  end

  def test_score_of_a_triple_1_is_1000
    assert_equal 1000, score([1,1,1])
  end

  def test_score_of_other_triples_is_100x
    assert_equal 200, score([2,2,2])
    assert_equal 300, score([3,3,3])
    assert_equal 400, score([4,4,4])
    assert_equal 500, score([5,5,5])
    assert_equal 600, score([6,6,6])
  end

  def test_score_of_mixed_is_sum
    assert_equal 250, score([2,5,2,2,3])
    assert_equal 550, score([5,5,5,5])
  end

end

Looks nice. My only comment would to replace your uses of #each with a more appropriate #inject, since that is what you are doing.
The pattern of
initialize accumulator
loop with each to add things into accumulator
return accumulator

is the use of #inject

Also, instead of putting guard clauses into the #each, looking into using #select. This refactoring can often make the code more flexible.

Added a benchmark against three versions including this ... https://gist.github.com/1091056 ... was wondering what the impact of the multiple enumerations would be ... this one comes out as pretty inefficient ... though admittedly in the grand scheme, this probably wouldn't be called 500,000 times in a tight loop :)