<h2>Edit File - ruby.vim</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/share/vim/vim80/indent/ruby.vim">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot; Vim indent file
&quot; Language:		Ruby
&quot; Maintainer:		Nikolai Weibull &lt;now at bitwi.se&gt;
&quot; URL:			https://github.com/vim-ruby/vim-ruby
&quot; Release Coordinator:	Doug Kearns &lt;dougkearns@gmail.com&gt;

&quot; 0. Initialization {{{1
&quot; =================

&quot; Only load this indent file when no other was loaded.
if exists(&quot;b:did_indent&quot;)
  finish
endif
let b:did_indent = 1

if !exists(&#039;g:ruby_indent_access_modifier_style&#039;)
  &quot; Possible values: &quot;normal&quot;, &quot;indent&quot;, &quot;outdent&quot;
  let g:ruby_indent_access_modifier_style = &#039;normal&#039;
endif

if !exists(&#039;g:ruby_indent_block_style&#039;)
  &quot; Possible values: &quot;expression&quot;, &quot;do&quot;
  let g:ruby_indent_block_style = &#039;expression&#039;
endif

setlocal nosmartindent

&quot; Now, set up our indentation expression and keys that trigger it.
setlocal indentexpr=GetRubyIndent(v:lnum)
setlocal indentkeys=0{,0},0),0],!^F,o,O,e,:,.
setlocal indentkeys+==end,=else,=elsif,=when,=ensure,=rescue,==begin,==end
setlocal indentkeys+==private,=protected,=public

&quot; Only define the function once.
if exists(&quot;*GetRubyIndent&quot;)
  finish
endif

let s:cpo_save = &amp;cpo
set cpo&amp;vim

&quot; 1. Variables {{{1
&quot; ============

&quot; Regex of syntax group names that are or delimit strings/symbols or are comments.
let s:syng_strcom = &#039;\&lt;ruby\%(Regexp\|RegexpDelimiter\|RegexpEscape&#039; .
      \ &#039;\|Symbol\|String\|StringDelimiter\|StringEscape\|ASCIICode&#039; .
      \ &#039;\|Interpolation\|InterpolationDelimiter\|NoInterpolation\|Comment\|Documentation\)\&gt;&#039;

&quot; Regex of syntax group names that are strings.
let s:syng_string =
      \ &#039;\&lt;ruby\%(String\|Interpolation\|NoInterpolation\|StringEscape\)\&gt;&#039;

&quot; Regex of syntax group names that are strings or documentation.
let s:syng_stringdoc =
      \&#039;\&lt;ruby\%(String\|Interpolation\|NoInterpolation\|StringEscape\|Documentation\)\&gt;&#039;

&quot; Expression used to check whether we should skip a match with searchpair().
let s:skip_expr =
      \ &quot;synIDattr(synID(line(&#039;.&#039;),col(&#039;.&#039;),1),&#039;name&#039;) =~ &#039;&quot;.s:syng_strcom.&quot;&#039;&quot;

&quot; Regex used for words that, at the start of a line, add a level of indent.
let s:ruby_indent_keywords =
      \ &#039;^\s*\zs\&lt;\%(module\|class\|if\|for&#039; .
      \   &#039;\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure\|rescue&#039; .
      \   &#039;\|\%(public\|protected\|private\)\=\s*def\):\@!\&gt;&#039; .
      \ &#039;\|\%([=,*/%+-]\|&lt;&lt;\|&gt;&gt;\|:\s\)\s*\zs&#039; .
      \    &#039;\&lt;\%(if\|for\|while\|until\|case\|unless\|begin\):\@!\&gt;&#039;

&quot; Regex used for words that, at the start of a line, remove a level of indent.
let s:ruby_deindent_keywords =
      \ &#039;^\s*\zs\&lt;\%(ensure\|else\|rescue\|elsif\|when\|end\):\@!\&gt;&#039;

&quot; Regex that defines the start-match for the &#039;end&#039; keyword.
&quot;let s:end_start_regex = &#039;\%(^\|[^.]\)\&lt;\%(module\|class\|def\|if\|for\|while\|until\|case\|unless\|begin\|do\)\&gt;&#039;
&quot; TODO: the do here should be restricted somewhat (only at end of line)?
let s:end_start_regex =
      \ &#039;\C\%(^\s*\|[=,*/%+\-|;{]\|&lt;&lt;\|&gt;&gt;\|:\s\)\s*\zs&#039; .
      \ &#039;\&lt;\%(module\|class\|if\|for\|while\|until\|case\|unless\|begin&#039; .
      \   &#039;\|\%(public\|protected\|private\)\=\s*def\):\@!\&gt;&#039; .
      \ &#039;\|\%(^\|[^.:@$]\)\@&lt;=\&lt;do:\@!\&gt;&#039;

&quot; Regex that defines the middle-match for the &#039;end&#039; keyword.
let s:end_middle_regex = &#039;\&lt;\%(ensure\|else\|\%(\%(^\|;\)\s*\)\@&lt;=\&lt;rescue:\@!\&gt;\|when\|elsif\):\@!\&gt;&#039;

&quot; Regex that defines the end-match for the &#039;end&#039; keyword.
let s:end_end_regex = &#039;\%(^\|[^.:@$]\)\@&lt;=\&lt;end:\@!\&gt;&#039;

&quot; Expression used for searchpair() call for finding match for &#039;end&#039; keyword.
let s:end_skip_expr = s:skip_expr .
      \ &#039; || (expand(&quot;&lt;cword&gt;&quot;) == &quot;do&quot;&#039; .
      \ &#039; &amp;&amp; getline(&quot;.&quot;) =~ &quot;^\\s*\\&lt;\\(while\\|until\\|for\\):\\@!\\&gt;&quot;)&#039;

&quot; Regex that defines continuation lines, not including (, {, or [.
let s:non_bracket_continuation_regex =
      \ &#039;\%([\\.,:*/%+]\|\&lt;and\|\&lt;or\|\%(&lt;%\)\@&lt;![=-]\|:\@&lt;![^[:alnum:]:][|&amp;?]\|||\|&amp;&amp;\)\s*\%(#.*\)\=$&#039;

&quot; Regex that defines continuation lines.
let s:continuation_regex =
      \ &#039;\%(%\@&lt;![({[\\.,:*/%+]\|\&lt;and\|\&lt;or\|\%(&lt;%\)\@&lt;![=-]\|:\@&lt;![^[:alnum:]:][|&amp;?]\|||\|&amp;&amp;\)\s*\%(#.*\)\=$&#039;

&quot; Regex that defines continuable keywords
let s:continuable_regex =
      \ &#039;\C\%(^\s*\|[=,*/%+\-|;{]\|&lt;&lt;\|&gt;&gt;\|:\s\)\s*\zs&#039; .
      \ &#039;\&lt;\%(if\|for\|while\|until\|unless\):\@!\&gt;&#039;

&quot; Regex that defines bracket continuations
let s:bracket_continuation_regex = &#039;%\@&lt;!\%([({[]\)\s*\%(#.*\)\=$&#039;

&quot; Regex that defines dot continuations
let s:dot_continuation_regex = &#039;%\@&lt;!\.\s*\%(#.*\)\=$&#039;

&quot; Regex that defines backslash continuations
let s:backslash_continuation_regex = &#039;%\@&lt;!\\\s*$&#039;

&quot; Regex that defines end of bracket continuation followed by another continuation
let s:bracket_switch_continuation_regex = &#039;^\([^(]\+\zs).\+\)\+&#039;.s:continuation_regex

&quot; Regex that defines the first part of a splat pattern
let s:splat_regex = &#039;[[,(]\s*\*\s*\%(#.*\)\=$&#039;

&quot; Regex that describes all indent access modifiers
let s:access_modifier_regex = &#039;\C^\s*\%(public\|protected\|private\)\s*\%(#.*\)\=$&#039;

&quot; Regex that describes the indent access modifiers (excludes public)
let s:indent_access_modifier_regex = &#039;\C^\s*\%(protected\|private\)\s*\%(#.*\)\=$&#039;

&quot; Regex that defines blocks.
&quot;
&quot; Note that there&#039;s a slight problem with this regex and s:continuation_regex.
&quot; Code like this will be matched by both:
&quot;
&quot;   method_call do |(a, b)|
&quot;
&quot; The reason is that the pipe matches a hanging &quot;|&quot; operator.
&quot;
let s:block_regex =
      \ &#039;\%(\&lt;do:\@!\&gt;\|%\@&lt;!{\)\s*\%(|[^|]*|\)\=\s*\%(#.*\)\=$&#039;

let s:block_continuation_regex = &#039;^\s*[^])}\t ].*&#039;.s:block_regex

&quot; Regex that describes a leading operator (only a method call&#039;s dot for now)
let s:leading_operator_regex = &#039;^\s*[.]&#039;

&quot; 2. Auxiliary Functions {{{1
&quot; ======================

&quot; Check if the character at lnum:col is inside a string, comment, or is ascii.
function s:IsInStringOrComment(lnum, col)
  return synIDattr(synID(a:lnum, a:col, 1), &#039;name&#039;) =~ s:syng_strcom
endfunction

&quot; Check if the character at lnum:col is inside a string.
function s:IsInString(lnum, col)
  return synIDattr(synID(a:lnum, a:col, 1), &#039;name&#039;) =~ s:syng_string
endfunction

&quot; Check if the character at lnum:col is inside a string or documentation.
function s:IsInStringOrDocumentation(lnum, col)
  return synIDattr(synID(a:lnum, a:col, 1), &#039;name&#039;) =~ s:syng_stringdoc
endfunction

&quot; Check if the character at lnum:col is inside a string delimiter
function s:IsInStringDelimiter(lnum, col)
  return synIDattr(synID(a:lnum, a:col, 1), &#039;name&#039;) == &#039;rubyStringDelimiter&#039;
endfunction

&quot; Find line above &#039;lnum&#039; that isn&#039;t empty, in a comment, or in a string.
function s:PrevNonBlankNonString(lnum)
  let in_block = 0
  let lnum = prevnonblank(a:lnum)
  while lnum &gt; 0
    &quot; Go in and out of blocks comments as necessary.
    &quot; If the line isn&#039;t empty (with opt. comment) or in a string, end search.
    let line = getline(lnum)
    if line =~ &#039;^=begin&#039;
      if in_block
        let in_block = 0
      else
        break
      endif
    elseif !in_block &amp;&amp; line =~ &#039;^=end&#039;
      let in_block = 1
    elseif !in_block &amp;&amp; line !~ &#039;^\s*#.*$&#039; &amp;&amp; !(s:IsInStringOrComment(lnum, 1)
          \ &amp;&amp; s:IsInStringOrComment(lnum, strlen(line)))
      break
    endif
    let lnum = prevnonblank(lnum - 1)
  endwhile
  return lnum
endfunction

&quot; Find line above &#039;lnum&#039; that started the continuation &#039;lnum&#039; may be part of.
function s:GetMSL(lnum)
  &quot; Start on the line we&#039;re at and use its indent.
  let msl = a:lnum
  let msl_body = getline(msl)
  let lnum = s:PrevNonBlankNonString(a:lnum - 1)
  while lnum &gt; 0
    &quot; If we have a continuation line, or we&#039;re in a string, use line as MSL.
    &quot; Otherwise, terminate search as we have found our MSL already.
    let line = getline(lnum)

    if !s:Match(msl, s:backslash_continuation_regex) &amp;&amp;
          \ s:Match(lnum, s:backslash_continuation_regex)
      &quot; If the current line doesn&#039;t end in a backslash, but the previous one
      &quot; does, look for that line&#039;s msl
      &quot;
      &quot; Example:
      &quot;   foo = &quot;bar&quot; \
      &quot;     &quot;baz&quot;
      &quot;
      let msl = lnum
    elseif s:Match(msl, s:leading_operator_regex)
      &quot; If the current line starts with a leading operator, keep its indent
      &quot; and keep looking for an MSL.
      let msl = lnum
    elseif s:Match(lnum, s:splat_regex)
      &quot; If the above line looks like the &quot;*&quot; of a splat, use the current one&#039;s
      &quot; indentation.
      &quot;
      &quot; Example:
      &quot;   Hash[*
      &quot;     method_call do
      &quot;       something
      &quot;
      return msl
    elseif s:Match(lnum, s:non_bracket_continuation_regex) &amp;&amp;
          \ s:Match(msl, s:non_bracket_continuation_regex)
      &quot; If the current line is a non-bracket continuation and so is the
      &quot; previous one, keep its indent and continue looking for an MSL.
      &quot;
      &quot; Example:
      &quot;   method_call one,
      &quot;     two,
      &quot;     three
      &quot;
      let msl = lnum
    elseif s:Match(lnum, s:dot_continuation_regex) &amp;&amp;
          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
      &quot; If the current line is a bracket continuation or a block-starter, but
      &quot; the previous is a dot, keep going to see if the previous line is the
      &quot; start of another continuation.
      &quot;
      &quot; Example:
      &quot;   parent.
      &quot;     method_call {
      &quot;     three
      &quot;
      let msl = lnum
    elseif s:Match(lnum, s:non_bracket_continuation_regex) &amp;&amp;
          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
      &quot; If the current line is a bracket continuation or a block-starter, but
      &quot; the previous is a non-bracket one, respect the previous&#039; indentation,
      &quot; and stop here.
      &quot;
      &quot; Example:
      &quot;   method_call one,
      &quot;     two {
      &quot;     three
      &quot;
      return lnum
    elseif s:Match(lnum, s:bracket_continuation_regex) &amp;&amp;
          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
      &quot; If both lines are bracket continuations (the current may also be a
      &quot; block-starter), use the current one&#039;s and stop here
      &quot;
      &quot; Example:
      &quot;   method_call(
      &quot;     other_method_call(
      &quot;       foo
      return msl
    elseif s:Match(lnum, s:block_regex) &amp;&amp;
          \ !s:Match(msl, s:continuation_regex) &amp;&amp;
          \ !s:Match(msl, s:block_continuation_regex)
      &quot; If the previous line is a block-starter and the current one is
      &quot; mostly ordinary, use the current one as the MSL.
      &quot;
      &quot; Example:
      &quot;   method_call do
      &quot;     something
      &quot;     something_else
      return msl
    else
      let col = match(line, s:continuation_regex) + 1
      if (col &gt; 0 &amp;&amp; !s:IsInStringOrComment(lnum, col))
            \ || s:IsInString(lnum, strlen(line))
        let msl = lnum
      else
        break
      endif
    endif

    let msl_body = getline(msl)
    let lnum = s:PrevNonBlankNonString(lnum - 1)
  endwhile
  return msl
endfunction

&quot; Check if line &#039;lnum&#039; has more opening brackets than closing ones.
function s:ExtraBrackets(lnum)
  let opening = {&#039;parentheses&#039;: [], &#039;braces&#039;: [], &#039;brackets&#039;: []}
  let closing = {&#039;parentheses&#039;: [], &#039;braces&#039;: [], &#039;brackets&#039;: []}

  let line = getline(a:lnum)
  let pos  = match(line, &#039;[][(){}]&#039;, 0)

  &quot; Save any encountered opening brackets, and remove them once a matching
  &quot; closing one has been found. If a closing bracket shows up that doesn&#039;t
  &quot; close anything, save it for later.
  while pos != -1
    if !s:IsInStringOrComment(a:lnum, pos + 1)
      if line[pos] == &#039;(&#039;
        call add(opening.parentheses, {&#039;type&#039;: &#039;(&#039;, &#039;pos&#039;: pos})
      elseif line[pos] == &#039;)&#039;
        if empty(opening.parentheses)
          call add(closing.parentheses, {&#039;type&#039;: &#039;)&#039;, &#039;pos&#039;: pos})
        else
          let opening.parentheses = opening.parentheses[0:-2]
        endif
      elseif line[pos] == &#039;{&#039;
        call add(opening.braces, {&#039;type&#039;: &#039;{&#039;, &#039;pos&#039;: pos})
      elseif line[pos] == &#039;}&#039;
        if empty(opening.braces)
          call add(closing.braces, {&#039;type&#039;: &#039;}&#039;, &#039;pos&#039;: pos})
        else
          let opening.braces = opening.braces[0:-2]
        endif
      elseif line[pos] == &#039;[&#039;
        call add(opening.brackets, {&#039;type&#039;: &#039;[&#039;, &#039;pos&#039;: pos})
      elseif line[pos] == &#039;]&#039;
        if empty(opening.brackets)
          call add(closing.brackets, {&#039;type&#039;: &#039;]&#039;, &#039;pos&#039;: pos})
        else
          let opening.brackets = opening.brackets[0:-2]
        endif
      endif
    endif

    let pos = match(line, &#039;[][(){}]&#039;, pos + 1)
  endwhile

  &quot; Find the rightmost brackets, since they&#039;re the ones that are important in
  &quot; both opening and closing cases
  let rightmost_opening = {&#039;type&#039;: &#039;(&#039;, &#039;pos&#039;: -1}
  let rightmost_closing = {&#039;type&#039;: &#039;)&#039;, &#039;pos&#039;: -1}

  for opening in opening.parentheses + opening.braces + opening.brackets
    if opening.pos &gt; rightmost_opening.pos
      let rightmost_opening = opening
    endif
  endfor

  for closing in closing.parentheses + closing.braces + closing.brackets
    if closing.pos &gt; rightmost_closing.pos
      let rightmost_closing = closing
    endif
  endfor

  return [rightmost_opening, rightmost_closing]
endfunction

function s:Match(lnum, regex)
  let line   = getline(a:lnum)
  let offset = match(line, &#039;\C&#039;.a:regex)
  let col    = offset + 1

  while offset &gt; -1 &amp;&amp; s:IsInStringOrComment(a:lnum, col)
    let offset = match(line, &#039;\C&#039;.a:regex, offset + 1)
    let col = offset + 1
  endwhile

  if offset &gt; -1
    return col
  else
    return 0
  endif
endfunction

&quot; Locates the containing class/module&#039;s definition line, ignoring nested classes
&quot; along the way.
&quot;
function! s:FindContainingClass()
  let saved_position = getpos(&#039;.&#039;)

  while searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, &#039;bW&#039;,
        \ s:end_skip_expr) &gt; 0
    if expand(&#039;&lt;cword&gt;&#039;) =~# &#039;\&lt;class\|module\&gt;&#039;
      let found_lnum = line(&#039;.&#039;)
      call setpos(&#039;.&#039;, saved_position)
      return found_lnum
    endif
  endwhile

  call setpos(&#039;.&#039;, saved_position)
  return 0
endfunction

&quot; 3. GetRubyIndent Function {{{1
&quot; =========================

function GetRubyIndent(...)
  &quot; 3.1. Setup {{{2
  &quot; ----------

  &quot; The value of a single shift-width
  let sw = shiftwidth()

  &quot; For the current line, use the first argument if given, else v:lnum
  let clnum = a:0 ? a:1 : v:lnum

  &quot; Set up variables for restoring position in file.  Could use clnum here.
  let vcol = col(&#039;.&#039;)

  &quot; 3.2. Work on the current line {{{2
  &quot; -----------------------------

  &quot; Get the current line.
  let line = getline(clnum)
  let ind = -1

  &quot; If this line is an access modifier keyword, align according to the closest
  &quot; class declaration.
  if g:ruby_indent_access_modifier_style == &#039;indent&#039;
    if s:Match(clnum, s:access_modifier_regex)
      let class_line = s:FindContainingClass()
      if class_line &gt; 0
        return indent(class_line) + sw
      endif
    endif
  elseif g:ruby_indent_access_modifier_style == &#039;outdent&#039;
    if s:Match(clnum, s:access_modifier_regex)
      let class_line = s:FindContainingClass()
      if class_line &gt; 0
        return indent(class_line)
      endif
    endif
  endif

  &quot; If we got a closing bracket on an empty line, find its match and indent
  &quot; according to it.  For parentheses we indent to its column - 1, for the
  &quot; others we indent to the containing line&#039;s MSL&#039;s level.  Return -1 if fail.
  let col = matchend(line, &#039;^\s*[]})]&#039;)
  if col &gt; 0 &amp;&amp; !s:IsInStringOrComment(clnum, col)
    call cursor(clnum, col)
    let bs = strpart(&#039;(){}[]&#039;, stridx(&#039;)}]&#039;, line[col - 1]) * 2, 2)
    if searchpair(escape(bs[0], &#039;\[&#039;), &#039;&#039;, bs[1], &#039;bW&#039;, s:skip_expr) &gt; 0
      if line[col-1]==&#039;)&#039; &amp;&amp; col(&#039;.&#039;) != col(&#039;$&#039;) - 1
        let ind = virtcol(&#039;.&#039;) - 1
      elseif g:ruby_indent_block_style == &#039;do&#039;
        let ind = indent(line(&#039;.&#039;))
      else &quot; g:ruby_indent_block_style == &#039;expression&#039;
        let ind = indent(s:GetMSL(line(&#039;.&#039;)))
      endif
    endif
    return ind
  endif

  &quot; If we have a =begin or =end set indent to first column.
  if match(line, &#039;^\s*\%(=begin\|=end\)$&#039;) != -1
    return 0
  endif

  &quot; If we have a deindenting keyword, find its match and indent to its level.
  &quot; TODO: this is messy
  if s:Match(clnum, s:ruby_deindent_keywords)
    call cursor(clnum, 1)
    if searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, &#039;bW&#039;,
          \ s:end_skip_expr) &gt; 0
      let msl  = s:GetMSL(line(&#039;.&#039;))
      let line = getline(line(&#039;.&#039;))

      if strpart(line, 0, col(&#039;.&#039;) - 1) =~ &#039;=\s*$&#039; &amp;&amp;
            \ strpart(line, col(&#039;.&#039;) - 1, 2) !~ &#039;do&#039;
        &quot; assignment to case/begin/etc, on the same line, hanging indent
        let ind = virtcol(&#039;.&#039;) - 1
      elseif g:ruby_indent_block_style == &#039;do&#039;
        &quot; align to line of the &quot;do&quot;, not to the MSL
        let ind = indent(line(&#039;.&#039;))
      elseif getline(msl) =~ &#039;=\s*\(#.*\)\=$&#039;
        &quot; in the case of assignment to the MSL, align to the starting line,
        &quot; not to the MSL
        let ind = indent(line(&#039;.&#039;))
      else
        &quot; align to the MSL
        let ind = indent(msl)
      endif
    endif
    return ind
  endif

  &quot; If we are in a multi-line string or line-comment, don&#039;t do anything to it.
  if s:IsInStringOrDocumentation(clnum, matchend(line, &#039;^\s*&#039;) + 1)
    return indent(&#039;.&#039;)
  endif

  &quot; If we are at the closing delimiter of a &quot;&lt;&lt;&quot; heredoc-style string, set the
  &quot; indent to 0.
  if line =~ &#039;^\k\+\s*$&#039;
        \ &amp;&amp; s:IsInStringDelimiter(clnum, 1)
        \ &amp;&amp; search(&#039;\V&lt;&lt;&#039;.line, &#039;nbW&#039;) &gt; 0
    return 0
  endif

  &quot; If the current line starts with a leading operator, add a level of indent.
  if s:Match(clnum, s:leading_operator_regex)
    return indent(s:GetMSL(clnum)) + sw
  endif

  &quot; 3.3. Work on the previous line. {{{2
  &quot; -------------------------------

  &quot; Find a non-blank, non-multi-line string line above the current line.
  let lnum = s:PrevNonBlankNonString(clnum - 1)

  &quot; If the line is empty and inside a string, use the previous line.
  if line =~ &#039;^\s*$&#039; &amp;&amp; lnum != prevnonblank(clnum - 1)
    return indent(prevnonblank(clnum))
  endif

  &quot; At the start of the file use zero indent.
  if lnum == 0
    return 0
  endif

  &quot; Set up variables for the previous line.
  let line = getline(lnum)
  let ind = indent(lnum)

  if g:ruby_indent_access_modifier_style == &#039;indent&#039;
    &quot; If the previous line was a private/protected keyword, add a
    &quot; level of indent.
    if s:Match(lnum, s:indent_access_modifier_regex)
      return indent(lnum) + sw
    endif
  elseif g:ruby_indent_access_modifier_style == &#039;outdent&#039;
    &quot; If the previous line was a private/protected/public keyword, add
    &quot; a level of indent, since the keyword has been out-dented.
    if s:Match(lnum, s:access_modifier_regex)
      return indent(lnum) + sw
    endif
  endif

  if s:Match(lnum, s:continuable_regex) &amp;&amp; s:Match(lnum, s:continuation_regex)
    return indent(s:GetMSL(lnum)) + sw + sw
  endif

  &quot; If the previous line ended with a block opening, add a level of indent.
  if s:Match(lnum, s:block_regex)
    let msl = s:GetMSL(lnum)

    if g:ruby_indent_block_style == &#039;do&#039;
      &quot; don&#039;t align to the msl, align to the &quot;do&quot;
      let ind = indent(lnum) + sw
    elseif getline(msl) =~ &#039;=\s*\(#.*\)\=$&#039;
      &quot; in the case of assignment to the msl, align to the starting line,
      &quot; not to the msl
      let ind = indent(lnum) + sw
    else
      let ind = indent(msl) + sw
    endif
    return ind
  endif

  &quot; If the previous line started with a leading operator, use its MSL&#039;s level
  &quot; of indent
  if s:Match(lnum, s:leading_operator_regex)
    return indent(s:GetMSL(lnum))
  endif

  &quot; If the previous line ended with the &quot;*&quot; of a splat, add a level of indent
  if line =~ s:splat_regex
    return indent(lnum) + sw
  endif

  &quot; If the previous line contained unclosed opening brackets and we are still
  &quot; in them, find the rightmost one and add indent depending on the bracket
  &quot; type.
  &quot;
  &quot; If it contained hanging closing brackets, find the rightmost one, find its
  &quot; match and indent according to that.
  if line =~ &#039;[[({]&#039; || line =~ &#039;[])}]\s*\%(#.*\)\=$&#039;
    let [opening, closing] = s:ExtraBrackets(lnum)

    if opening.pos != -1
      if opening.type == &#039;(&#039; &amp;&amp; searchpair(&#039;(&#039;, &#039;&#039;, &#039;)&#039;, &#039;bW&#039;, s:skip_expr) &gt; 0
        if col(&#039;.&#039;) + 1 == col(&#039;$&#039;)
          return ind + sw
        else
          return virtcol(&#039;.&#039;)
        endif
      else
        let nonspace = matchend(line, &#039;\S&#039;, opening.pos + 1) - 1
        return nonspace &gt; 0 ? nonspace : ind + sw
      endif
    elseif closing.pos != -1
      call cursor(lnum, closing.pos + 1)
      normal! %

      if s:Match(line(&#039;.&#039;), s:ruby_indent_keywords)
        return indent(&#039;.&#039;) + sw
      else
        return indent(s:GetMSL(line(&#039;.&#039;)))
      endif
    else
      call cursor(clnum, vcol)
    end
  endif

  &quot; If the previous line ended with an &quot;end&quot;, match that &quot;end&quot;s beginning&#039;s
  &quot; indent.
  let col = s:Match(lnum, &#039;\%(^\|[^.:@$]\)\&lt;end\&gt;\s*\%(#.*\)\=$&#039;)
  if col &gt; 0
    call cursor(lnum, col)
    if searchpair(s:end_start_regex, &#039;&#039;, s:end_end_regex, &#039;bW&#039;,
          \ s:end_skip_expr) &gt; 0
      let n = line(&#039;.&#039;)
      let ind = indent(&#039;.&#039;)
      let msl = s:GetMSL(n)
      if msl != n
        let ind = indent(msl)
      end
      return ind
    endif
  end

  let col = s:Match(lnum, s:ruby_indent_keywords)
  if col &gt; 0
    call cursor(lnum, col)
    let ind = virtcol(&#039;.&#039;) - 1 + sw
    &quot; TODO: make this better (we need to count them) (or, if a searchpair
    &quot; fails, we know that something is lacking an end and thus we indent a
    &quot; level
    if s:Match(lnum, s:end_end_regex)
      let ind = indent(&#039;.&#039;)
    endif
    return ind
  endif

  &quot; 3.4. Work on the MSL line. {{{2
  &quot; --------------------------

  &quot; Set up variables to use and search for MSL to the previous line.
  let p_lnum = lnum
  let lnum = s:GetMSL(lnum)

  &quot; If the previous line wasn&#039;t a MSL.
  if p_lnum != lnum
    &quot; If previous line ends bracket and begins non-bracket continuation decrease indent by 1.
    if s:Match(p_lnum, s:bracket_switch_continuation_regex)
      return ind - 1
    &quot; If previous line is a continuation return its indent.
    &quot; TODO: the || s:IsInString() thing worries me a bit.
    elseif s:Match(p_lnum, s:non_bracket_continuation_regex) || s:IsInString(p_lnum,strlen(line))
      return ind
    endif
  endif

  &quot; Set up more variables, now that we know we wasn&#039;t continuation bound.
  let line = getline(lnum)
  let msl_ind = indent(lnum)

  &quot; If the MSL line had an indenting keyword in it, add a level of indent.
  &quot; TODO: this does not take into account contrived things such as
  &quot; module Foo; class Bar; end
  if s:Match(lnum, s:ruby_indent_keywords)
    let ind = msl_ind + sw
    if s:Match(lnum, s:end_end_regex)
      let ind = ind - sw
    endif
    return ind
  endif

  &quot; If the previous line ended with [*+/.,-=], but wasn&#039;t a block ending or a
  &quot; closing bracket, indent one extra level.
  if s:Match(lnum, s:non_bracket_continuation_regex) &amp;&amp; !s:Match(lnum, &#039;^\s*\([\])}]\|end\)&#039;)
    if lnum == p_lnum
      let ind = msl_ind + sw
    else
      let ind = msl_ind
    endif
    return ind
  endif

  &quot; }}}2

  return ind
endfunction

&quot; }}}1

let &amp;cpo = s:cpo_save
unlet s:cpo_save

&quot; vim:set sw=2 sts=2 ts=8 et:
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>