Wie entferne ich führende Leerzeichen aus Ruby HEREDOC?

Ich habe ein Problem mit einem Ruby-Heredoc, den ich machen möchte. Es gibt das führende Leerzeichen aus jeder Zeile zurück, obwohl ich den Operator - einschließe, der alle führenden Leerzeichen unterdrücken soll. Meine Methode sieht so aus:

    def distinct_count
    <<-EOF
        \tSELECT
        \t CAST('#{name}' AS VARCHAR(30)) as COLUMN_NAME
        \t,COUNT(DISTINCT #{name}) AS DISTINCT_COUNT
        \tFROM #{table.call}
    EOF
end

und meine Ausgabe sieht so aus:

    => "            \tSELECT\n            \t CAST('SRC_ACCT_NUM' AS VARCHAR(30)) as
COLUMN_NAME\n            \t,COUNT(DISTINCT SRC_ACCT_NUM) AS DISTINCT_COUNT\n
        \tFROM UD461.MGMT_REPORT_HNB\n"

Dies ist natürlich in diesem speziellen Fall richtig, mit Ausnahme aller Leerzeichen zwischen dem ersten "und \ t. Weiß jemand, was ich hier falsch mache?

Die <<-Form von Heredoc ignoriert nur führende Leerzeichen für das Endtrennzeichen.

Mit Ruby 2.3 und höher können Sie ein schnörkelloses heredoc ( <<~) verwenden, um das führende Leerzeichen von Inhaltszeilen zu unterdrücken:

def test
  <<~END
    First content line.
      Two spaces here.
    No space here.
  END
end

test
# => "First content line.\n  Two spaces here.\nNo space here.\n"

Aus der Ruby- Literaldokumentation :

Der Einzug der am wenigsten eingerückten Zeile wird aus jeder Zeile des Inhalts entfernt. Beachten Sie, dass leere Zeilen und Zeilen, die ausschließlich aus wörtlichen Tabulatoren und Leerzeichen bestehen, zum Bestimmen der Einrückung ignoriert werden, maskierte Tabulatoren und Leerzeichen jedoch als Zeichen ohne Einrückung betrachtet werden.

Wenn Sie Rails 3.0 oder höher verwenden, versuchen Sie es #strip_heredoc. In diesem Beispiel aus den Dokumenten werden die ersten drei Zeilen ohne Einrückung gedruckt, wobei die Zwei-Leerzeichen-Einrückung der letzten beiden Zeilen beibehalten wird:

if options[:usage]
  puts <<-USAGE.strip_heredoc
    This command does such and such.
 
    Supported options are:
      -h         This message
      ...
  USAGE
end

In der Dokumentation heißt es außerdem: "Technisch wird nach der am wenigsten eingerückten Zeile in der gesamten Zeichenfolge gesucht und diese Menge an führenden Leerzeichen entfernt."

Hier ist die Implementierung von active_support / core_ext / string / strip.rb :

class String
  def strip_heredoc
    indent = scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
    gsub(/^[ \t]{#{indent}}/, '')
  end
end

Die Tests finden Sie in test / core_ext / string_ext_test.rb .

Ich fürchte, ich habe nicht viel zu tun. Normalerweise mache ich:

def distinct_count
    <<-EOF.gsub /^\s+/, ""
        \tSELECT
        \t CAST('#{name}' AS VARCHAR(30)) as COLUMN_NAME
        \t,COUNT(DISTINCT #{name}) AS DISTINCT_COUNT
        \tFROM #{table.call}
    EOF
end

Das funktioniert aber ist ein bisschen ein Hack.

EDIT: Ich lasse mich von Rene Saarsoo inspirieren und schlage stattdessen Folgendes vor:

class String
  def unindent 
    gsub(/^#{scan(/^\s*/).min_by{|l|l.length}}/, "")
  end
end

def distinct_count
    <<-EOF.unindent
        \tSELECT
        \t CAST('#{name}' AS VARCHAR(30)) as COLUMN_NAME
        \t,COUNT(DISTINCT #{name}) AS DISTINCT_COUNT
        \tFROM #{table.call}
    EOF
end

Diese Version sollte funktionieren, wenn die erste Zeile nicht die am weitesten links liegende ist.

Hier ist eine weitaus einfachere Version des nicht eingerückten Skripts, das ich verwende:

class String
  # Strip leading whitespace from each line that is the same as the 
  # amount of whitespace on the first line of the string.
  # Leaves _additional_ indentation on later lines intact.
  def unindent
    gsub /^#{self[/\A[ \t]*/]}/, ''
  end
end

Verwenden Sie es so:

foo = {
  bar: <<-ENDBAR.unindent
    My multiline
      and indented
        content here
    Yay!
  ENDBAR
}
#=> {:bar=>"My multiline\n  and indented\n    content here\nYay!"}

Wenn die erste Zeile möglicherweise stärker als andere eingerückt ist und (wie Rails) basierend auf der am wenigsten eingerückten Zeile nicht eingerückt werden soll, möchten Sie möglicherweise stattdessen Folgendes verwenden:

class String
  # Strip leading whitespace from each line that is the same as the 
  # amount of whitespace on the least-indented line of the string.
  def strip_indent
    if mindent=scan(/^[ \t]+/).min_by(&:length)
      gsub /^#{mindent}/, ''
    end
  end
end

Beachten Sie, dass beim Scannen nach \s+statt [ \t]+möglicherweise Zeilenumbrüche aus Ihrem Heredoc entfernt werden, anstatt Leerzeichen zu führen. Nicht wünschenswert!

<<-In Ruby wird nur das führende Leerzeichen für das Endtrennzeichen ignoriert, sodass es ordnungsgemäß eingerückt werden kann. Das führende Leerzeichen in Zeilen innerhalb der Zeichenfolge wird nicht entfernt, obwohl dies in einigen Online-Dokumentationen möglicherweise steht.

Sie können führende Leerzeichen selbst entfernen, indem Sie Folgendes verwenden gsub:

<<-EOF.gsub /^\s*/, ''
    \tSELECT
    \t CAST('#{name}' AS VARCHAR(30)) as COLUMN_NAME
    \t,COUNT(DISTINCT #{name}) AS DISTINCT_COUNT
    \tFROM #{table.call}
EOF

Oder wenn Sie nur Leerzeichen entfernen möchten, lassen Sie die Registerkarten:

<<-EOF.gsub /^ */, ''
    \tSELECT
    \t CAST('#{name}' AS VARCHAR(30)) as COLUMN_NAME
    \t,COUNT(DISTINCT #{name}) AS DISTINCT_COUNT
    \tFROM #{table.call}
EOF

Einige andere Antworten finden die Einrückungsebene der geringsten eingekerbten Linie , und löschen Sie, dass aus allen Linien, aber die Art der Vertiefung unter Berücksichtigung bei der Programmierung (dass die erste Zeile ist die am wenigsten eingerückt), ich glaube , Sie für die Vertiefung Niveau aussehen sollte die erste Zeile .

class String
  def unindent; gsub(/^#{match(/^\s+/)}/, "") end
end

Wie das Originalplakat entdeckte auch ich die <<-HEREDOCSyntax und war verdammt enttäuscht, dass sie sich nicht so verhielt, wie ich es mir vorgestellt hatte.

Aber anstatt meinen Code mit gsub-s zu verunreinigen, habe ich die String-Klasse erweitert:

class String
  # Removes beginning-whitespace from each line of a string.
  # But only as many whitespace as the first line has.
  #
  # Ment to be used with heredoc strings like so:
  #
  # text = <<-EOS.unindent
  #   This line has no indentation
  #     This line has 2 spaces of indentation
  #   This line is also not indented
  # EOS
  #
  def unindent
    lines = []
    each_line {|ln| lines << ln }

    first_line_ws = lines[0].match(/^\s+/)[0]
    re = Regexp.new('^\s{0,' + first_line_ws.length.to_s + '}')

    lines.collect {|line| line.sub(re, "") }.join
  end
end

Hinweis: Wie @radiospiel hervorhob, String#squishist es nur im ActiveSupportKontext verfügbar .

Ich glaube Ruby ist String#squish ist näher an dem, wonach Sie wirklich suchen:

So würde ich mit Ihrem Beispiel umgehen:

def distinct_count
  <<-SQL.squish
    SELECT
      CAST('#{name}' AS VARCHAR(30)) as COLUMN_NAME,
      COUNT(DISTINCT #{name}) AS DISTINCT_COUNT
      FROM #{table.call}
  SQL
end

Eine andere leicht zu merkende Option ist die Verwendung eines nicht eingerückten Edelsteins

require 'unindent'

p <<-end.unindent
    hello
      world
  end
# => "hello\n  world\n"  

Ich musste etwas verwenden, mit systemdem ich lange sedBefehle über Zeilen aufteilen und dann Einrückungen UND Zeilenumbrüche entfernen konnte ...

def update_makefile(build_path, version, sha1)
  system <<-CMD.strip_heredoc(true)
    \\sed -i".bak"
    -e "s/GIT_VERSION[\ ]*:=.*/GIT_VERSION := 20171-2342/g"
    -e "s/GIT_VERSION_SHA1[\ ]:=.*/GIT_VERSION_SHA1 := 2342/g"
    "/tmp/Makefile"
  CMD
end

Also habe ich mir Folgendes ausgedacht:

class ::String
  def strip_heredoc(compress = false)
    stripped = gsub(/^#{scan(/^\s*/).min_by(&:length)}/, "")
    compress ? stripped.gsub(/\n/," ").chop : stripped
  end
end

Standardmäßig werden keine Zeilenumbrüche entfernt, wie bei allen anderen Beispielen.

Ich sammle Antworten und habe Folgendes erhalten:

class Match < ActiveRecord::Base
  has_one :invitation
  scope :upcoming, -> do
    joins(:invitation)
    .where(<<-SQL_QUERY.strip_heredoc, Date.current, Date.current).order('invitations.date ASC')
      CASE WHEN invitations.autogenerated_for_round IS NULL THEN invitations.date >= ?
      ELSE (invitations.round_end_time >= ? AND match_plays.winner_id IS NULL) END
    SQL_QUERY
  end
end

Es generiert exzellentes SQL und verlässt nicht die AR-Bereiche.