¿Cómo elimino los caracteres de espacios en blanco iniciales de Ruby HEREDOC?

Tengo un problema con un heredoc de Ruby que estoy intentando hacer. Devuelve el espacio en blanco inicial de cada línea a pesar de que incluyo el operador -, que se supone que suprime todos los espacios en blanco iniciales. mi método se ve así:

    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

y mi salida se ve así:

    => "            \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"

esto, por supuesto, es correcto en este caso específico, excepto por todos los espacios entre el primer "y \ t. ¿Alguien sabe lo que estoy haciendo mal aquí?

La <<-forma de heredoc solo ignora los espacios en blanco iniciales para el delimitador final.

Con Ruby 2.3 y versiones posteriores, puede usar un heredoc ( <<~) ondulado para suprimir el espacio en blanco inicial de las líneas de contenido:

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"

De la documentación de Ruby literals :

La sangría de la línea con menos sangría se eliminará de cada línea del contenido. Tenga en cuenta que las líneas vacías y las líneas que constan únicamente de tabulaciones y espacios literales se ignorarán para determinar la sangría, pero las tabulaciones y los espacios de escape se consideran caracteres sin sangría.

Si está utilizando Rails 3.0 o más reciente, inténtelo #strip_heredoc. Este ejemplo de los documentos imprime las primeras tres líneas sin sangría, mientras que conserva la sangría de dos espacios de las dos últimas líneas:

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

La documentación también señala: "Técnicamente, busca la línea con menos sangría en toda la cadena y elimina esa cantidad de espacios en blanco iniciales".

Aquí está la implementación de 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

Y puede encontrar las pruebas en test / core_ext / string_ext_test.rb .

No hay mucho que hacer que yo sepa, me temo. Yo suelo hacer:

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

Eso funciona, pero es un truco.

EDITAR: Inspirándome en Rene Saarsoo a continuación, sugeriría algo como esto en su lugar:

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

Esta versión debería funcionar cuando la primera línea no es la más a la izquierda.

Aquí hay una versión mucho más simple del script sin sangría que uso:

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

Úselo así:

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

Si la primera línea puede tener más sangría que otras y desea (como Rails) eliminar la sangría en función de la línea con menos sangría, puede que desee utilizar:

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

Tenga en cuenta que si busca en \s+lugar de [ \t]+, puede terminar eliminando nuevas líneas de su heredoc en lugar de espacios en blanco iniciales. ¡No deseable!

<<-en Ruby solo ignorará el espacio inicial para el delimitador final, lo que permitirá que tenga una sangría adecuada. No elimina el espacio inicial en las líneas dentro de la cadena, a pesar de lo que pueda decir alguna documentación en línea.

Puede eliminar los espacios en blanco iniciales usted mismo utilizando 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

O si solo desea eliminar espacios, dejando las pestañas:

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

Algunas otras respuestas encontrar el nivel de sangría de la línea menos sangría , y eliminar que a partir de todas las líneas, pero teniendo en cuenta la naturaleza de la muesca en la programación (que la primera línea es el menos sangría), creo que se debe buscar el nivel de sangría de la primera línea .

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

Al igual que el póster original, yo también descubrí la <<-HEREDOCsintaxis y me decepcionó mucho que no se comportara como yo pensaba que debería comportarse.

Pero en lugar de ensuciar mi código con gsub-s, extendí la clase String:

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

Nota: Como señaló @radiospiel, String#squishsolo está disponible en el ActiveSupportcontexto.

Yo creo ruby String#squish está más cerca de lo que realmente estás buscando:

Así es como manejaría su ejemplo:

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

otra opción fácil de recordar es usar gema sin sangría

require 'unindent'

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

Necesitaba usar algo con systemlo que pudiera dividir sedcomandos largos en líneas y luego eliminar la sangría Y las nuevas líneas ...

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

Entonces se me ocurrió esto:

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

El comportamiento predeterminado es no eliminar las nuevas líneas, como todos los demás ejemplos.

Recopilo respuestas y obtuve esto:

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

Genera un excelente SQL y no se sale de los alcances de AR.