StringCalculator recursivo

StringCalculator.rb

require 'rspec'
class StringCalculator
  def add(string)
    return add(string_without_last_summand(string)) + last_summand(string) if more_than_one_summand?(string)
    string.to_i
  end
  def string_without_last_summand(string)
    string[0...last_separator_index(string)]
  end
  def last_summand(string)
    string[last_separator_index(string) + 1..-1].to_i
  end
  def more_than_one_summand?(string)
    string.include?(',') || string.include?("\n")
  end
  def separator
    return /,|\n/
  end
  def last_separator_index(string)
    -1*(string.reverse.index(separator) + 1)
  end
end

Yo te propondría dos acercamientos. Perdona si los hago en c#, ruby no lo controlo nada.

1. Como dice eamodeorubio, string sería una propiedad de la clase. Lo cual te permitiria no tener que declararla en cada una de las firmas:
   private string numerosACalcular {get; set;}

Así los métodos no necesitan tener en su firma el string de marras que, como bien dices, huele fatal.

Pero, y aquí viene lo bueno, al ser una propiedad, nos permite realizar el usar el patron de null object para tratar los casos en que el strin venga a nulo y que aun no tienes en cuenta en tu código. O, también, tratar el string para ver si cumple las condiciones necesarias como que se puedan obtener al menos dos números, etc.

Además permite decidir cuando y donde se introduce el string en la clase, desacoplando la clase del tipo de dato esperado, en este caso string.

¿Cómo? Creando un constructor estático de la clase. Así desacoplamos la clase y aumentamos el desacoplamiento de la misma:
public static int StringCalculator(string textoConNumeros);
{
numerosACalcular = textoConNumeros;
StringCalculator Calculador = new StringCalculator();
return Calculador.Add();
}

Y en Ruby, seguro que queda aún más compacto el código.

Espero haber sido de ayuda.

1.- No puedes usar NullObject con un string.
2.- Eso que has puesto no es un constructor. No sé que pretendes con ese código, pero... O_o
3.- No sé dónde ni de qué estás intentando desacoplar.

ja, ja, ja. Tienes razón Alberto, me explico como un libro cerrado. A ver si ahora me hago entender mejor.

1. string cadena = (textoConNumero == null ? string.empty : textoConNumero) Patrón null object para tipo string. De echo, creo, este patron es para objetos, no importa el tipo del mismo. También se puede hacer de forma clásica con una variable privada y una propiedad pública, pero a mi me resulta más engorroso.
   De todas formas es un tecnicismo, a lo que me quería referir es que la clase se podría mejorar si trata los objetos nulos o el que la cadena de texto no contenga números, o (si fuera c#) problemas de desbordamiento de enteros que no sé si en ruby hay que tenerlos en cuenta, etc.
2. Tienes toda la razón. Es confuso. Pero es aún más, en Ruby es inecesario, por lo que he podido leer, el tema de los métodos estáticos. Olvida el parrafo entero. En C# tiene sentido, en Ruby por lo poco que he leido, no.
3. Estaba intentando evitar StringCalculator.new("1,2,3").add y convertirlo en StringCalculator.calcula("1,2,3") que me parece mucho más legible. Desacoplar la cadena de texto del constructor. Así se puede construir la clase/objeto no importando que las firmas sean diferentes. Ya se encargará la propia clase de gestionar cada una, ocultando el "como" se hacen las cosas y solamente devolviendo el resultado.

Por último, agradecerte la contestación porque me ha "picado" a leer un poquito de Ruby para poder intentar aclarar lo mal que me he explicado, y me he encontrado sorprendido con las diferencias. Y me ha causado mucha curiosidad.