Ruby: Puis-je écrire une chaîne multi-lignes sans concaténation?

Existe-t-il un moyen de rendre cela un peu meilleur?

conn.exec 'select attr1, attr2, attr3, attr4, attr5, attr6, attr7 ' +
          'from table1, table2, table3, etc, etc, etc, etc, etc, ' +
          'where etc etc etc etc etc etc etc etc etc etc etc etc etc'

Par exemple, existe-t-il un moyen d'impliquer la concaténation?

Il y a des éléments dans cette réponse qui m'ont aidé à obtenir ce dont j'avais besoin (concaténation multi-lignes facile SANS espace supplémentaire), mais comme aucune des réponses réelles ne l'avait, je les compile ici:

str = 'this is a multi-line string'\
  ' using implicit concatenation'\
  ' to prevent spare \n\'s'

=> "this is a multi-line string using implicit concatenation to eliminate spare
\\n's"

En bonus, voici une version utilisant une drôle de syntaxe HEREDOC (via ce lien ):

p <<END_SQL.gsub(/\s+/, " ").strip
SELECT * FROM     users
         ORDER BY users.id DESC
END_SQL
# >> "SELECT * FROM users ORDER BY users.id DESC"

Ces derniers concerneraient principalement des situations nécessitant plus de flexibilité dans le traitement. Personnellement, je ne l'aime pas, cela place le traitement dans un endroit étrange par rapport à la chaîne (c'est-à-dire devant, mais en utilisant des méthodes d'instance qui viennent généralement après), mais il est là. Notez que si vous indentez le dernier END_SQLidentifiant (ce qui est courant, car il s'agit probablement d'une fonction ou d'un module), vous devrez utiliser la syntaxe avec trait d'union (c'est-à-dire p <<-END_SQLau lieu de p <<END_SQL). Sinon, le blanc en retrait induit l'interpréteur comme une continuation de la chaîne.

Cela n'économise pas beaucoup de frappe, mais cela me semble plus agréable que d'utiliser des signes +.

De plus (je dis dans une édition, plusieurs années plus tard), si vous utilisez Ruby 2.3+, l'opérateur << ~ est également disponible , ce qui supprime l'indentation supplémentaire de la chaîne finale. Vous devriez pouvoir supprimer l' .gsubinvocation, dans ce cas (bien que cela puisse dépendre à la fois de l'indentation de départ et de vos besoins finaux).

EDIT: Ajout d'un plus:

p %{
SELECT * FROM     users
         ORDER BY users.id DESC
}.gsub(/\s+/, " ").strip
# >> "SELECT * FROM users ORDER BY users.id DESC"

Dans ruby ​​2.0, vous pouvez maintenant simplement utiliser %

Par exemple:

SQL = %{
SELECT user, name
FROM users
WHERE users.id = #{var}
LIMIT #{var2}
}

Oui, si cela ne vous dérange pas l'insertion de nouvelles lignes supplémentaires:

 conn.exec 'select attr1, attr2, attr3, attr4, attr5, attr6, attr7
            from table1, table2, table3, etc, etc, etc, etc, etc,
            where etc etc etc etc etc etc etc etc etc etc etc etc etc'

Vous pouvez également utiliser un hérédoc :

conn.exec <<-eos
   select attr1, attr2, attr3, attr4, attr5, attr6, attr7
   from table1, table2, table3, etc, etc, etc, etc, etc,
   where etc etc etc etc etc etc etc etc etc etc etc etc etc
eos

Il existe plusieurs syntaxes pour les chaînes multilignes comme vous l'avez déjà lu. Mon préféré est le style Perl:

conn.exec %q{select attr1, attr2, attr3, attr4, attr5, attr6, attr7
      from table1, table2, table3, etc, etc, etc, etc, etc,
      where etc etc etc etc etc etc etc etc etc etc etc etc etc}

La chaîne multiligne commence par% q, suivie d'un {, [ou (, puis se termine par le caractère inversé correspondant.% Q ne permet pas l'interpolation;% Q le fait, vous pouvez donc écrire des choses comme ceci:

conn.exec %Q{select attr1, attr2, attr3, attr4, attr5, attr6, attr7
      from #{table_names},
      where etc etc etc etc etc etc etc etc etc etc etc etc etc}

En fait, je n'ai aucune idée de la façon dont ces types de chaînes multi-lignes sont appelés alors appelons-les simplement multilignes Perl.

Notez cependant que si vous utilisez des multilignes Perl ou des heredocs comme l'ont suggéré Mark et Peter, vous vous retrouverez avec des espaces blancs potentiellement inutiles. Dans mes exemples et leurs exemples, les lignes "from" et "where" contiennent des espaces blancs de début en raison de leur retrait dans le code. Si cet espace n'est pas souhaité, vous devez utiliser des chaînes concaténées comme vous le faites maintenant.

Il vaut parfois la peine de supprimer de nouveaux caractères de ligne \ncomme:

conn.exec <<-eos.squish
 select attr1, attr2, attr3, attr4, attr5, attr6, attr7
 from table1, table2, table3, etc, etc, etc, etc, etc,
 where etc etc etc etc etc etc etc etc etc etc etc etc etc
eos

Vous pouvez également utiliser des guillemets doubles

x = """
this is 
a multiline
string
"""

2.3.3 :012 > x
 => "\nthis is\na multiline\nstring\n"

Si nécessaire pour supprimer les sauts de ligne "\ n" utilisez une barre oblique inverse "\" à la fin de chaque ligne

conn.exec = <<eos
  select attr1, attr2, attr3, attr4, attr5, attr6, attr7
  from table1, table2, table3, etc, etc, etc, etc, etc,
  where etc etc etc etc etc etc etc etc etc etc etc etc etc
eos

Autres options:

#multi line string
multiline_string = <<EOM
This is a very long string
that contains interpolation
like #{4 + 5} \n\n
EOM

puts multiline_string

#another option for multiline string
message = <<-EOF
asdfasdfsador #{2+2} this month.
asdfadsfasdfadsfad.
EOF

puts message

Récemment, avec les nouvelles fonctionnalités de Ruby 2.3, la nouvelle squiggly HEREDOCvous permettra d'écrire nos chaînes multilignes de manière agréable avec un changement minimal, donc l'utilisation de cela combiné avec le .squish(si vous utilisez des rails) vous permettra d'écrire multiligne de manière agréable! en cas de simple utilisation de rubis, vous pouvez faire un <<~SQL.split.join(" ")qui est presque le même

[1] pry(main)> <<~SQL.squish
[1] pry(main)*   select attr1, attr2, attr3, attr4, attr5, attr6, attr7
[1] pry(main)*   from table1, table2, table3, etc, etc, etc, etc, etc,
[1] pry(main)*   where etc etc etc etc etc etc etc etc etc etc etc etc etc
[1] pry(main)* SQL
=> "select attr1, attr2, attr3, attr4, attr5, attr6, attr7 from table1, table2, table3, etc, etc, etc, etc, etc, where etc etc etc etc etc etc etc etc etc etc etc etc etc"

réf: https://infinum.co/the-capsized-eight/multiline-strings-ruby-2-3-0-the-squiggly-heredoc

conn.exec 'select attr1, attr2, attr3, attr4, attr5, attr6, attr7 ' <<
        'from table1, table2, table3, etc, etc, etc, etc, etc, ' <<
        'where etc etc etc etc etc etc etc etc etc etc etc etc etc'

<< est l'opérateur de concaténation des chaînes

Si vous faites l' esprit des espaces supplémentaires et des sauts de ligne, vous pouvez utiliser

conn.exec %w{select attr1, attr2, attr3, attr4, attr5, attr6, attr7
  from table1, table2, table3, etc, etc, etc, etc, etc,
  where etc etc etc etc etc etc etc etc etc etc etc etc etc} * ' '

(utilisez% W pour les chaînes interpolées)

Pour éviter de fermer les parenthèses pour chaque ligne, vous pouvez simplement utiliser des guillemets doubles avec une barre oblique inverse pour échapper à la nouvelle ligne:

"select attr1, attr2, attr3, attr4, attr5, attr6, attr7 \
from table1, table2, table3, etc, etc, etc, etc, etc, \
where etc etc etc etc etc etc etc etc etc etc etc etc etc"

conn.exec [
  "select attr1, attr2, attr3, ...",
  "from table1, table2, table3, ...",
  "where ..."
].join(' ')

Cette suggestion a l'avantage sur les documents et les chaînes longues ici que les auto-indenters peuvent indenter chaque partie de la chaîne de manière appropriée. Mais cela a un coût d'efficacité.

Le Ruby-way (TM) depuis Ruby 2.3: Utilisez le HEREDOC ondulé <<~ pour définir une chaîne multi-lignes avec des retours à la ligne et une indentation appropriée:

conn.exec <<~EOS
            select attr1, attr2, attr3, attr4, attr5, attr6, attr7
            from table1, table2, table3, etc, etc, etc, etc, etc
            where etc etc etc etc etc etc etc etc etc etc etc etc etc
          EOS

# -> "select...\nfrom...\nwhere..."

Si l'indentation appropriée n'est pas un problème, les guillemets simples et doubles peuvent s'étendre sur plusieurs lignes dans Ruby:

conn.exec "select attr1, attr2, attr3, attr4, attr5, attr6, attr7 
           from table1, table2, table3, etc, etc, etc, etc, etc, 
           where etc etc etc etc etc etc etc etc etc etc etc etc etc"    

# -> "select...\n           from...\n           where..."

Si les guillemets simples ou doubles sont lourds car cela nécessiterait beaucoup d'échappements, la notation littérale en pourcentage % est la solution la plus flexible:

conn.exec %(select attr1, attr2, attr3, attr4, attr5, attr6, attr7
            from table1, table2, table3, etc, etc, etc, etc, etc
            where (ProductLine = 'R' OR ProductLine = "S") AND Country = "...")
# -> "select...\n            from...\n            where..."

Si le but est d'éviter les sauts de ligne (que provoqueront à la fois HEREDOC, les guillemets et le pourcentage de littéral de chaîne), une continuation de ligne peut être utilisée en mettant une barre oblique inverse \comme dernier caractère non blanc dans une ligne. Cela continuera la ligne et obligera Ruby à concaténer les chaînes dos à dos (attention aux espaces à l'intérieur de la chaîne citée):

conn.exec 'select attr1, attr2, attr3, attr4, attr5, attr6, attr7 ' \
          'from table1, table2, table3, etc, etc, etc, etc, etc, ' \
          'where etc etc etc etc etc etc etc etc etc etc etc etc etc'

# -> "select...from...where..."

Si vous utilisez Rails String.squish, la chaîne des espaces de début et de fin sera supprimée et tous les espaces consécutifs (sauts de ligne, tabulations, etc.) seront réduits en un seul espace:

conn.exec "select attr1, attr2, attr3, attr4, attr5, attr6, attr7 
           from table1, table2, table3, etc, etc, etc, etc, etc, 
           where etc etc etc etc etc etc etc etc etc etc etc etc etc".squish

# -> "select...attr7 from...etc, where..."

Plus de détails:

Syntaxe Ruby HEREDOC

Le travail Here Document Notation for Strings est un moyen de désigner de longs blocs de texte en ligne dans le code. Il est démarré par <<suivi d'une chaîne définie par l'utilisateur (le terminateur de fin de chaîne). Toutes les lignes suivantes sont concaténées jusqu'à ce que le terminateur de fin de chaîne soit trouvé au tout début d'une ligne:

puts <<HEREDOC 
Text Text Text Text
Bla Bla
HEREDOC
# -> "Text Text Text Text\nBlaBla"

Le terminateur de fin de chaîne peut être choisi librement, mais il est courant d'utiliser quelque chose comme "EOS" (fin de chaîne) ou quelque chose qui correspond au domaine de la chaîne tel que "SQL".

HEREDOC prend en charge l' interpolation par défaut ou lorsque le terminateur EOS est entre guillemets:

price = 10
print <<"EOS"  # comments can be put here
1.) The price is #{price}.
EOS
# -> "1.) The price is 10."

L'interpolation peut être désactivée si le terminateur EOS est entre guillemets simples:

print <<'EOS' # Disabled interpolation
3.) The price is #{price}.
EOS
# -> "3.) The price is #{price}."

Une restriction importante de la <<HEREDOCest que le terminateur de fin de chaîne doit être au début de la ligne:

  puts <<EOS 
    def foo
      print "foo"
    end
  EOS
EOS
#-> "....def foo\n......print "foo"\n....end\n..EOS

Pour contourner cela, la <<-syntaxe a été créée. Il permet de mettre en retrait le terminateur EOS pour rendre le code plus agréable. Les lignes entre le <<-terminateur et EOS sont toujours utilisées dans leur extension complète, y compris toutes les indentations:

puts <<-EOS # Use <<- to indent End of String terminator
  def foo
    print "foo"
  end
EOS
# -> "..def foo\n....print "foo"\n..end"

Depuis Ruby 2.3, nous avons maintenant le squiggly HEREDOC <<~supprime les espaces blancs principaux:

puts <<~EOS # Use the squiggly HEREDOC <<~ to remove leading whitespace (since Ruby 2.3!)
  def foo
    print "foo"
  end
EOS
# -> "def foo\n..print "foo"\nend"

Les lignes vides et les lignes qui ne contiennent que des tabulations et de l'espace sont ignorées par << ~

puts <<~EOS.inspect 
  Hello

    World!
EOS
#-> "Hello\n..World!"

Si des tabulations et des espaces sont utilisés, les tabulations sont considérées comme égales à 8 espaces. Si la ligne la moins indentée se trouve au milieu d'un onglet, cet onglet n'est pas supprimé.

puts <<~EOS.inspect
<tab>One Tab
<space><space>Two Spaces
EOS
# -> "\tOne Tab\nTwoSpaces"

HEREDOC peut faire des choses folles telles que l'exécution de commandes à l'aide de backticks:

puts <<`EOC`            
echo #{price}
echo #{price * 2}
EOC

Les définitions de chaîne HEREDOC peuvent être "empilées", ce qui signifie que le premier terminateur EOS (EOSFOO ci-dessous) terminera la première chaîne et démarrera la seconde (EOSBAR ci-dessous):

print <<EOSFOO, <<EOSBAR    # you can stack them
I said foo.
EOSFOO
I said bar.
EOSBAR

Je ne pense pas que quiconque l'utiliserait jamais en tant que tel, mais <<EOSc'est vraiment juste un littéral de chaîne et peut être mis là où une chaîne peut normalement être mise:

def func(a,b,c)
  puts a
  puts b
  puts c
end

func(<<THIS, 23, <<THAT) 
Here's a line
or two.
THIS
and here's another.
THAT

Si vous n'avez pas Ruby 2.3, mais Rails >=3.0, vous pouvez utiliser String.strip_heredocce qui fait la même chose que<<~

# File activesupport/lib/active_support/core_ext/string/strip.rb, line 22
class String
  def strip_heredoc
    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
  end
end

puts <<-USAGE.strip_heredoc # If no Ruby 2.3, but Rails >= 3.0
  This command does such and such.

  Supported options are:
    -h         This message
    ...
USAGE

Pourcentages de chaînes de caractères

Voir RubyDoc pour savoir comment utiliser le signe de pourcentage suivi d'une chaîne dans une paire de parenthèses comme un %(...), %[...],%{...} , etc. ou une paire de tout caractère non alphanumérique tel%+...+

Derniers mots

Enfin, pour obtenir la réponse à la question initiale "Existe-t-il un moyen d'impliquer la concaténation?" répondu: Ruby implique toujours la concaténation si deux chaînes (simples et doubles entre guillemets) se trouvent dos à dos:

puts "select..." 'from table...' "where..."
# -> "select...from table...where..."

La mise en garde est que cela ne fonctionne pas entre les sauts de ligne, car Ruby interprète une fin de déclaration et la ligne conséquente de chaînes uniquement sur une ligne ne fait rien.

Réponse élégante aujourd'hui:

<<~TEXT
Hi #{user.name}, 

Thanks for raising the flag, we're always happy to help you.
Your issue will be resolved within 2 hours.
Please be patient!

Thanks again,
Team #{user.organization.name}
TEXT

Il y a une différence dans <<-TEXTet<<~TEXT , l'ancien conserve l'espacement à l'intérieur du bloc et ce dernier ne le fait pas.

Il existe également d'autres options. Comme la concaténation, etc., mais celle-ci a plus de sens en général.

Si je me trompe ici, faites-moi savoir comment ...

Comme vous, je cherchais également une solution qui n'inclut pas les retours à la ligne . (Bien qu'ils puissent être sûrs en SQL, ils ne le sont pas dans mon cas et j'ai un gros bloc de texte à traiter)

C'est sans doute tout aussi laid, mais vous pouvez annuler les sauts de ligne dans un hérédoc pour les omettre de la chaîne résultante:

conn.exec <<~END_OF_INPUT
    select attr1, attr2, attr3, attr4, attr5, attr6, attr7 \
    from table1, table2, table3, etc, etc, etc, etc, etc, \
    where etc etc etc etc etc etc etc etc etc etc etc etc etc
  END_OF_INPUT

Notez que vous ne pouvez pas le faire sans interpolation (IE <<~'END_OF_INPUT'), alors soyez prudent. #{expressions}seront évalués ici, alors qu'ils ne le seront pas dans votre code d'origine. La réponse de A. Wilson peut être meilleure pour cette raison.