Sto cercando di convertire un nome da caso serpente a caso cammello. Ci sono metodi integrati?

Ad esempio: "app_user"a"AppUser"

(Ho una stringa "app_user"che voglio convertire in modello AppUser).

Se stai usando Rails, String # camelize è quello che stai cercando.

  "active_record".camelize                # => "ActiveRecord"
  "active_record".camelize(:lower)        # => "activeRecord"

Se vuoi ottenere una classe reale, dovresti usare String # constantize per di più.

"app_user".camelize.constantize

Che ne dici di questo?

"hello_world".split('_').collect(&:capitalize).join #=> "HelloWorld"

Si trova nei commenti qui: Classificare una stringa Ruby

Vedi commento di Wayne Conrad

Se si utilizza Rails, utilizzare classify. Gestisce bene i casi limite.

"app_user".classify # => AppUser
"user_links".classify   # => UserLink

Nota:

Questa risposta è specifica per la descrizione fornita nella domanda (non è specifica per il titolo della domanda). Se si sta cercando di convertire una stringa in una custodia di cammello, dovrebbero usare la risposta di Sergio . L'interrogante afferma che vuole convertirsi app_userin AppUser(non App_user), quindi questa risposta ..

Fonte: http://rubydoc.info/gems/extlib/0.9.15/String#camel_case-instance_method

Ai fini dell'apprendimento:

class String
  def camel_case
    return self if self !~ /_/ && self =~ /[A-Z]+.*/
    split('_').map{|e| e.capitalize}.join
  end
end

"foo_bar".camel_case          #=> "FooBar"

E per la variante lowerCase:

class String
  def camel_case_lower
    self.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
  end
end

"foo_bar".camel_case_lower          #=> "fooBar"

Punto di riferimento per soluzioni Ruby pure

Ho colto tutte le possibilità che avevo in mente per farlo con un codice rubino puro, eccoli qui:

• capitalizzare e gsub

  'app_user'.capitalize.gsub(/_(\w)/){$1.upcase}

• dividere e mappare usando la &scorciatoia (grazie alla risposta dell'utente3869936)

  'app_user'.split('_').map(&:capitalize).join

• dividere e mappare (grazie alla risposta di Mr. Black)

  'app_user'.split('_').map{|e| e.capitalize}.join

Ed ecco il benchmark per tutti questi, possiamo vedere che gsub è abbastanza male per questo. Ho usato 126 080 parole.

                              user     system      total        real
capitalize and gsub  :      0.360000   0.000000   0.360000 (  0.357472)
split and map, with &:      0.190000   0.000000   0.190000 (  0.189493)
split and map        :      0.170000   0.000000   0.170000 (  0.171859)

Sono arrivato qui a cercare l'inverso della tua domanda, passando da una custodia per cammelli a una custodia per serpenti. Usa il carattere di sottolineatura per quello (non decamelize):

AppUser.name.underscore # => "app_user"

oppure, se hai già una stringa di custodia di cammello:

"AppUser".underscore # => "app_user"

o, se si desidera ottenere il nome della tabella, è probabilmente il motivo per cui si desidera la custodia del serpente:

AppUser.name.tableize # => "app_users"

Mi sento un po 'a disagio ad aggiungere più risposte qui. Ha deciso di optare per l'approccio di rubino puro più leggibile e minimale, ignorando il bel punto di riferimento di @ ulysse-bn. Mentre :classmode è una copia di @ user3869936, la :methodmodalità che non vedo in nessun'altra risposta qui.

  def snake_to_camel_case(str, mode: :class)
    case mode
    when :class
      str.split('_').map(&:capitalize).join
    when :method
      str.split('_').inject { |m, p| m + p.capitalize }
    else
      raise "unknown mode #{mode.inspect}"
    end
  end

Il risultato è:

[28] pry(main)> snake_to_camel_case("asd_dsa_fds", mode: :class)
=> "AsdDsaFds"
[29] pry(main)> snake_to_camel_case("asd_dsa_fds", mode: :method)
=> "asdDsaFds"

La maggior parte degli altri metodi elencati qui sono specifici di Rails. Se vuoi farlo con Ruby puro, il seguente è il modo più conciso che ho escogitato (grazie a @ ulysse-bn per il miglioramento suggerito)

x="this_should_be_camel_case"
x.gsub(/(?:_|^)(\w)/){$1.upcase}
    #=> "ThisShouldBeCamelCase"

Estendi stringa per aggiungere Camelize

In puro Ruby puoi estendere la classe di stringhe usando lo stesso codice esatto di Rails .camelize

class String
  def camelize(uppercase_first_letter = true)
    string = self
    if uppercase_first_letter
      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
    else
      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
    end
    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
  end
end