mirror of
https://github.com/SpaceVim/SpaceVim.git
synced 2025-02-04 09:40:03 +08:00
1906 lines
35 KiB
Ruby
1906 lines
35 KiB
Ruby
require 'spec_helper'
|
|
|
|
describe "ruby" do
|
|
let(:filename) { 'test.rb' }
|
|
|
|
before :each do
|
|
vim.set(:expandtab)
|
|
vim.set(:shiftwidth, 2)
|
|
end
|
|
|
|
after :each do
|
|
vim.command('silent! unlet g:splitjoin_ruby_trailing_comma')
|
|
vim.command('silent! unlet g:splitjoin_ruby_heredoc_type')
|
|
vim.command('silent! unlet g:splitjoin_ruby_hanging_args')
|
|
vim.command('silent! unlet g:splitjoin_ruby_do_block_split')
|
|
vim.command('silent! unlet g:splitjoin_trailing_comma')
|
|
vim.command('silent! unlet g:splitjoin_ruby_options_as_arguments')
|
|
vim.command('silent! unlet g:splitjoin_ruby_curly_braces')
|
|
vim.command('silent! unlet g:splitjoin_ruby_expand_options_in_arrays')
|
|
end
|
|
|
|
specify "if-clauses" do
|
|
set_file_contents <<~EOF
|
|
return "the answer" if 6 * 9 == 42
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
if 6 * 9 == 42
|
|
return "the answer"
|
|
end
|
|
EOF
|
|
|
|
vim.search 'if'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
return "the answer" if 6 * 9 == 42
|
|
EOF
|
|
end
|
|
|
|
specify "if-clauses with comments and interpolation" do
|
|
set_file_contents <<~EOF
|
|
if 6 * 9 == 42
|
|
return "the \#{right} answer" # comment
|
|
end
|
|
EOF
|
|
|
|
vim.search 'if'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
# comment
|
|
return "the \#{right} answer" if 6 * 9 == 42
|
|
EOF
|
|
end
|
|
|
|
describe "module namespaces" do
|
|
specify "with contents" do
|
|
set_file_contents <<~EOF
|
|
module Foo
|
|
module Bar
|
|
class Baz < Quux
|
|
def initialize
|
|
# foo
|
|
end
|
|
end
|
|
end
|
|
end
|
|
EOF
|
|
|
|
vim.search 'Foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
class Foo::Bar::Baz < Quux
|
|
def initialize
|
|
# foo
|
|
end
|
|
end
|
|
EOF
|
|
|
|
vim.search 'Foo'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
module Foo
|
|
module Bar
|
|
class Baz < Quux
|
|
def initialize
|
|
# foo
|
|
end
|
|
end
|
|
end
|
|
end
|
|
EOF
|
|
end
|
|
|
|
specify "without contents" do
|
|
set_file_contents <<~EOF
|
|
module Foo
|
|
module Bar
|
|
class Baz < Quux
|
|
end
|
|
end
|
|
end
|
|
EOF
|
|
|
|
vim.search 'Foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
class Foo::Bar::Baz < Quux
|
|
end
|
|
EOF
|
|
|
|
vim.search 'Foo'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
module Foo
|
|
module Bar
|
|
class Baz < Quux
|
|
end
|
|
end
|
|
end
|
|
EOF
|
|
end
|
|
|
|
specify "with one-letter names" do
|
|
set_file_contents <<~EOF
|
|
module A
|
|
module B
|
|
end
|
|
end
|
|
EOF
|
|
|
|
vim.search 'A'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
module A::B
|
|
end
|
|
EOF
|
|
|
|
vim.search 'A::B'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
module A
|
|
module B
|
|
end
|
|
end
|
|
EOF
|
|
end
|
|
|
|
specify "merging namespaces" do
|
|
set_file_contents <<~EOF
|
|
module Foo::Bar
|
|
class Baz::Qux
|
|
end
|
|
end
|
|
EOF
|
|
|
|
vim.search 'Foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
class Foo::Bar::Baz::Qux
|
|
end
|
|
EOF
|
|
end
|
|
|
|
specify "with an rspec describe" do
|
|
set_file_contents <<~EOF
|
|
module Foo::Bar
|
|
RSpec.describe Baz do
|
|
end
|
|
end
|
|
EOF
|
|
|
|
vim.search 'Foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
RSpec.describe Foo::Bar::Baz do
|
|
end
|
|
EOF
|
|
|
|
vim.search 'RSpec'
|
|
vim.normal 'df.'
|
|
split
|
|
|
|
set_file_contents <<~EOF
|
|
module Foo
|
|
module Bar
|
|
describe Baz do
|
|
end
|
|
end
|
|
end
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "ternaries" do
|
|
it "handles simplistic ternaries" do
|
|
set_file_contents <<~EOF
|
|
condition ? 'this' : 'that'
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
if condition
|
|
'this'
|
|
else
|
|
'that'
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
condition ? 'this' : 'that'
|
|
EOF
|
|
end
|
|
|
|
it "handles comments" do
|
|
set_file_contents <<~EOF
|
|
if condition
|
|
'this' # comment
|
|
else
|
|
'that'
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
# comment
|
|
condition ? 'this' : 'that'
|
|
EOF
|
|
end
|
|
|
|
it "works with unless" do
|
|
set_file_contents <<~EOF
|
|
unless condition
|
|
x = 'a'
|
|
else
|
|
y = 'b'
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
condition ? y = 'b' : x = 'a'
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
if condition
|
|
y = 'b'
|
|
else
|
|
x = 'a'
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "extracts variable assignments" do
|
|
set_file_contents <<~EOF
|
|
if condition
|
|
x = 'a'
|
|
else
|
|
x = 'b'
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
x = (condition ? 'a' : 'b')
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
x = if condition
|
|
'a'
|
|
else
|
|
'b'
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "handles assignments when joining, adding parentheses" do
|
|
set_file_contents <<~EOF
|
|
x = if condition
|
|
'a'
|
|
else
|
|
'b'
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
x = (condition ? 'a' : 'b')
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
x = if condition
|
|
'a'
|
|
else
|
|
'b'
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "handles different formatting for assignments" do
|
|
set_file_contents <<~EOF
|
|
x = unless condition
|
|
'something'
|
|
else
|
|
'anything'
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
x = (condition ? 'anything' : 'something')
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
x = if condition
|
|
'anything'
|
|
else
|
|
'something'
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "handles ivars" do
|
|
set_file_contents <<~EOF
|
|
@variable.nil? ? do_something : do_something_else
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
if @variable.nil?
|
|
do_something
|
|
else
|
|
do_something_else
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
@variable.nil? ? do_something : do_something_else
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "when-then" do
|
|
it "joins when-then" do
|
|
set_file_contents <<~EOF
|
|
when condition
|
|
do_stuff
|
|
when condition
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
when condition then do_stuff
|
|
when condition
|
|
EOF
|
|
end
|
|
|
|
it "splits when-then" do
|
|
set_file_contents <<~EOF
|
|
when condition then do_stuff
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
when condition
|
|
do_stuff
|
|
EOF
|
|
end
|
|
|
|
it "works only when there is one line in the then body" do
|
|
set_file_contents <<~EOF
|
|
when condition
|
|
do_stuff
|
|
do_something_else
|
|
EOF
|
|
|
|
# Call command instead of mapping to avoid default mapping
|
|
vim.command 'SplitjoinJoin'
|
|
|
|
assert_file_contents <<~EOF
|
|
when condition
|
|
do_stuff
|
|
do_something_else
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "cases" do
|
|
it "joins cases with well formed when-thens" do
|
|
set_file_contents <<~EOF
|
|
case
|
|
when condition1
|
|
stuff1
|
|
when condition2
|
|
stuff2
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
case
|
|
when condition1 then stuff1
|
|
when condition2 then stuff2
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "passes over ill formed when thens do" do
|
|
set_file_contents <<~EOF
|
|
case
|
|
when condition1
|
|
stuff1
|
|
when condition2
|
|
stuff2
|
|
stuff3
|
|
when condition 3
|
|
stuff4
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
case
|
|
when condition1 then stuff1
|
|
when condition2
|
|
stuff2
|
|
stuff3
|
|
when condition 3 then stuff4
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "one-lines else as well" do
|
|
set_file_contents <<~EOF
|
|
case
|
|
when condition1
|
|
stuff1
|
|
when condition2
|
|
stuff2
|
|
else
|
|
stuff3
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
case
|
|
when condition1 then stuff1
|
|
when condition2 then stuff2
|
|
else stuff3
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "aligns thens in supercompact cases" do
|
|
set_file_contents <<~EOF
|
|
case
|
|
when cond1
|
|
stuff1
|
|
when condition2
|
|
stuff2
|
|
else
|
|
stuff3
|
|
end
|
|
EOF
|
|
|
|
vim.command('let b:splitjoin_align = 1')
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
case
|
|
when cond1 then stuff1
|
|
when condition2 then stuff2
|
|
else stuff3
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "doesn't one line else when the case is not well formed" do
|
|
set_file_contents <<~EOF
|
|
case
|
|
when condition1
|
|
stuff1
|
|
when condition2
|
|
stuff2
|
|
stuff3
|
|
else
|
|
stuff3
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
case
|
|
when condition1 then stuff1
|
|
when condition2
|
|
stuff2
|
|
stuff3
|
|
else
|
|
stuff3
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "expands/split all one liners in a case" do
|
|
set_file_contents <<~EOF
|
|
case
|
|
when condition1 then stuff1
|
|
when condition2
|
|
stuff2
|
|
else stuff3
|
|
end
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
case
|
|
when condition1
|
|
stuff1
|
|
when condition2
|
|
stuff2
|
|
else
|
|
stuff3
|
|
end
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "hashes" do
|
|
specify "with arrow syntax" do
|
|
set_file_contents <<~EOF
|
|
foo = { :bar => 'baz', :one => 'two' }
|
|
EOF
|
|
|
|
vim.search ':bar'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = {
|
|
:bar => 'baz',
|
|
:one => 'two'
|
|
}
|
|
EOF
|
|
|
|
vim.search 'foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = { :bar => 'baz', :one => 'two' }
|
|
EOF
|
|
end
|
|
|
|
specify "with symbol syntax" do
|
|
set_file_contents <<~EOF
|
|
foo = { bar: 1, one: 2 }
|
|
EOF
|
|
|
|
vim.search 'bar:'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = {
|
|
bar: 1,
|
|
one: 2
|
|
}
|
|
EOF
|
|
|
|
vim.search 'foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = { bar: 1, one: 2 }
|
|
EOF
|
|
end
|
|
|
|
specify "with string syntax and ':'" do
|
|
set_file_contents <<~EOF
|
|
foo = { 'bar baz ': 1, "one two ": 2 }
|
|
EOF
|
|
|
|
vim.search 'bar'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = {
|
|
'bar baz ': 1,
|
|
"one two ": 2
|
|
}
|
|
EOF
|
|
|
|
vim.search 'foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = { 'bar baz ': 1, "one two ": 2 }
|
|
EOF
|
|
end
|
|
|
|
specify "without a trailing comma" do
|
|
vim.command('let g:splitjoin_ruby_trailing_comma = 0')
|
|
|
|
set_file_contents <<~EOF
|
|
foo = { :bar => 'baz', :one => 'two' }
|
|
EOF
|
|
|
|
vim.search ':bar'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = {
|
|
:bar => 'baz',
|
|
:one => 'two'
|
|
}
|
|
EOF
|
|
end
|
|
|
|
specify "with a trailing comma" do
|
|
vim.command('let g:splitjoin_ruby_trailing_comma = 1')
|
|
|
|
set_file_contents <<~EOF
|
|
foo = { :bar => 'baz', :one => 'two' }
|
|
EOF
|
|
|
|
vim.search ':bar'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = {
|
|
:bar => 'baz',
|
|
:one => 'two',
|
|
}
|
|
EOF
|
|
|
|
vim.search 'foo'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo = { :bar => 'baz', :one => 'two' }
|
|
EOF
|
|
end
|
|
|
|
specify "with spaces in them" do
|
|
set_file_contents <<~EOF
|
|
a_hash = { a_key: "a longer value" }
|
|
EOF
|
|
|
|
vim.search 'a_key'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
a_hash = {
|
|
a_key: "a longer value"
|
|
}
|
|
EOF
|
|
end
|
|
end
|
|
|
|
specify "caching constructs" do
|
|
set_file_contents <<~EOF
|
|
@two ||= 1 + 1
|
|
EOF
|
|
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
@two ||= begin
|
|
1 + 1
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
@two ||= 1 + 1
|
|
EOF
|
|
end
|
|
|
|
specify "method continuations" do
|
|
set_file_contents <<~EOF
|
|
one.
|
|
two.
|
|
three
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
one.two.three
|
|
EOF
|
|
end
|
|
|
|
describe "blocks" do
|
|
it "splitjoins {}-blocks prepended by ?" do
|
|
set_file_contents <<~EOF
|
|
pens.any?{ |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
|
|
vim.search('to_sym')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
pens.any? do |pen|
|
|
pen.name.to_sym.in? names.flatten
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
pens.any? { |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
end
|
|
|
|
it "splitjoins {}-blocks prepended by !" do
|
|
set_file_contents <<~EOF
|
|
pens.find!{ |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
|
|
vim.search('to_sym')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
pens.find! do |pen|
|
|
pen.name.to_sym.in? names.flatten
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
pens.find! { |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
end
|
|
|
|
it "splitjoins {}-blocks prepended by -> ()" do
|
|
set_file_contents <<~EOF
|
|
-> (pen){ |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
|
|
vim.search('to_sym')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
-> (pen) do |pen|
|
|
pen.name.to_sym.in? names.flatten
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
-> (pen) { |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
end
|
|
|
|
it "splitjoins {}-blocks prepended by ->" do
|
|
set_file_contents <<~EOF
|
|
-> { |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
|
|
vim.search('to_sym')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
-> do |pen|
|
|
pen.name.to_sym.in? names.flatten
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
-> { |pen| pen.name.to_sym.in? names.flatten }
|
|
EOF
|
|
end
|
|
|
|
it "splitjoins {}-blocks without leading whitespace" do
|
|
set_file_contents <<~EOF
|
|
Bar.new{ |b| puts b.to_s }
|
|
EOF
|
|
|
|
vim.search('puts')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
Bar.new do |b|
|
|
puts b.to_s
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
Bar.new { |b| puts b.to_s }
|
|
EOF
|
|
end
|
|
|
|
it "splitjoins {}-blocks with arguments and do-end blocks" do
|
|
set_file_contents <<~EOF
|
|
Bar.new { |b| puts b.to_s }
|
|
EOF
|
|
|
|
vim.search('puts')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
Bar.new do |b|
|
|
puts b.to_s
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
Bar.new { |b| puts b.to_s }
|
|
EOF
|
|
end
|
|
|
|
it 'splitjoins {}-blocks without arguments and do-end blocks' do
|
|
set_file_contents <<~EOF
|
|
this { block doesnt, get: mangled }
|
|
EOF
|
|
|
|
vim.search 'block'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
this do
|
|
block doesnt, get: mangled
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
this { block doesnt, get: mangled }
|
|
EOF
|
|
end
|
|
|
|
it "splits {}-blocks into {}-blocks depending on a setting" do
|
|
vim.command('let g:splitjoin_ruby_do_block_split = 0')
|
|
|
|
set_file_contents <<~EOF
|
|
[1, 2, 3, 4].map { |i| i.to_s }
|
|
EOF
|
|
|
|
vim.search 'to_s'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
[1, 2, 3, 4].map { |i|
|
|
i.to_s
|
|
}
|
|
EOF
|
|
end
|
|
|
|
it "optimizes particular cases to &-shorthands" do
|
|
set_file_contents <<~EOF
|
|
[1, 2, 3, 4].map(&:to_s)
|
|
EOF
|
|
|
|
vim.search 'to_s'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
[1, 2, 3, 4].map do |i|
|
|
i.to_s
|
|
end
|
|
EOF
|
|
|
|
set_file_contents <<~EOF
|
|
[1, 2, 3, 4].map do |whatever|
|
|
whatever.to_s
|
|
end
|
|
EOF
|
|
|
|
vim.search 'whatever|'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
[1, 2, 3, 4].map(&:to_s)
|
|
EOF
|
|
end
|
|
|
|
it "handles trailing code" do
|
|
set_file_contents <<~EOF
|
|
Bar.new { |one| two }.map(&:name)
|
|
EOF
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
Bar.new do |one|
|
|
two
|
|
end.map(&:name)
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
Bar.new { |one| two }.map(&:name)
|
|
EOF
|
|
end
|
|
|
|
it "doesn't get confused by interpolation" do
|
|
set_file_contents <<~EOF
|
|
foo("\#{one}") { two }
|
|
EOF
|
|
|
|
vim.search 'two'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo("\#{one}") do
|
|
two
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "doesn't get confused by ; when joining" do
|
|
set_file_contents <<~EOF
|
|
foo do
|
|
example1
|
|
example2
|
|
end
|
|
EOF
|
|
|
|
vim.search 'do'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo { example1; example2 }
|
|
EOF
|
|
end
|
|
|
|
it "doesn't get confused by ; when splitting" do
|
|
set_file_contents <<~EOF
|
|
foo { example1; example2 }
|
|
EOF
|
|
|
|
vim.search 'example1;'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo do
|
|
example1
|
|
example2
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "doesn't get confused when ; is in a string literal(single quotes) when splitting" do
|
|
set_file_contents <<~EOF
|
|
foo { example1; 'some string ; literal' }
|
|
EOF
|
|
|
|
vim.search 'example1;'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo do
|
|
example1
|
|
'some string ; literal'
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "doesn't get confused when ; is in a string literal(double quotes) when splitting" do
|
|
set_file_contents <<~EOF
|
|
foo { example1; "some string ; literal" }
|
|
EOF
|
|
|
|
vim.search 'example1;'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo do
|
|
example1
|
|
"some string ; literal"
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "doesn't get confused when ; is in a string literal(percent strings) when splitting" do
|
|
set_file_contents <<~EOF
|
|
foo { example1; %(some string ; literal) }
|
|
EOF
|
|
|
|
vim.search 'example1;'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo do
|
|
example1
|
|
%(some string ; literal)
|
|
end
|
|
EOF
|
|
end
|
|
|
|
it "migrates inline comments when joining" do
|
|
set_file_contents <<~EOF
|
|
foo do
|
|
example # comment
|
|
end
|
|
EOF
|
|
|
|
vim.search 'do'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
# comment
|
|
foo { example }
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "heredocs" do
|
|
it "joins heredocs into single-quoted strings when possible" do
|
|
set_file_contents <<~EOF
|
|
string = <<~ANYTHING
|
|
something, "anything"
|
|
ANYTHING
|
|
EOF
|
|
|
|
vim.search 'ANYTHING'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
string = 'something, "anything"'
|
|
EOF
|
|
end
|
|
|
|
it "joins heredocs into double-quoted strings when there's a single-quoted string inside" do
|
|
set_file_contents <<~EOF
|
|
string = <<~ANYTHING
|
|
something, 'anything'
|
|
ANYTHING
|
|
EOF
|
|
|
|
vim.search 'ANYTHING'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
string = "something, 'anything'"
|
|
EOF
|
|
end
|
|
|
|
it "joins heredocs into double-quoted strings when there's interpolation inside" do
|
|
set_file_contents <<~EOF
|
|
string = <<~ANYTHING
|
|
something, \#{anything}
|
|
ANYTHING
|
|
EOF
|
|
|
|
vim.search 'ANYTHING'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
string = "something, \#{anything}"
|
|
EOF
|
|
end
|
|
|
|
it "splits normal strings into heredocs" do
|
|
vim.command('let g:splitjoin_ruby_heredoc_type = "<<-"')
|
|
|
|
set_file_contents 'string = "\"anything\""'
|
|
|
|
vim.search 'anything'
|
|
split
|
|
|
|
assert_file_contents <<~OUTER
|
|
string = <<-EOF
|
|
"anything"
|
|
EOF
|
|
OUTER
|
|
end
|
|
|
|
it "splits empty strings into empty heredocs" do
|
|
set_file_contents 'string = ""'
|
|
|
|
vim.search '"'
|
|
split
|
|
|
|
assert_file_contents <<~OUTER
|
|
string = <<~EOF
|
|
EOF
|
|
OUTER
|
|
end
|
|
|
|
it "can use the << heredoc style" do
|
|
vim.command('let g:splitjoin_ruby_heredoc_type = "<<"')
|
|
|
|
set_file_contents <<~EOF
|
|
do
|
|
string = "something"
|
|
end
|
|
EOF
|
|
|
|
vim.search 'something'
|
|
split
|
|
|
|
assert_file_contents <<~OUTER
|
|
do
|
|
string = <<EOF
|
|
something
|
|
EOF
|
|
end
|
|
OUTER
|
|
end
|
|
|
|
it "can use the <<~ heredoc style" do
|
|
vim.command('let g:splitjoin_ruby_heredoc_type = "<<~"')
|
|
|
|
set_file_contents <<~EOF
|
|
do
|
|
string = "something"
|
|
end
|
|
EOF
|
|
|
|
vim.search 'something'
|
|
split
|
|
|
|
assert_file_contents <<~OUTER
|
|
do
|
|
string = <<~EOF
|
|
something
|
|
EOF
|
|
end
|
|
OUTER
|
|
|
|
vim.search 'EOF'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
do
|
|
string = 'something'
|
|
end
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "method arguments" do
|
|
specify "with hanging args" do
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 1')
|
|
|
|
set_file_contents(<<~EOF)
|
|
params.permit(:title, :action, :subject_type, :subject_id, :own)
|
|
EOF
|
|
|
|
vim.search(':title')
|
|
split
|
|
|
|
assert_file_contents(<<~EOF)
|
|
params.permit(:title,
|
|
:action,
|
|
:subject_type,
|
|
:subject_id,
|
|
:own)
|
|
EOF
|
|
end
|
|
|
|
specify "without hanging args" do
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
|
|
set_file_contents(<<~EOF)
|
|
params.permit(:title, :action, :subject_type, :subject_id, :own)
|
|
EOF
|
|
|
|
vim.search(':title')
|
|
split
|
|
|
|
assert_file_contents(<<~EOF)
|
|
params.permit(
|
|
:title,
|
|
:action,
|
|
:subject_type,
|
|
:subject_id,
|
|
:own
|
|
)
|
|
EOF
|
|
end
|
|
|
|
specify "without brackets" do
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
|
|
set_file_contents(<<~EOF)
|
|
params.permit :title, :action, :subject_type, :subject_id, :own
|
|
EOF
|
|
|
|
vim.search(':title')
|
|
split
|
|
|
|
assert_file_contents(<<~EOF)
|
|
params.permit(
|
|
:title,
|
|
:action,
|
|
:subject_type,
|
|
:subject_id,
|
|
:own
|
|
)
|
|
EOF
|
|
end
|
|
|
|
specify "with spaces around brackets" do
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
|
|
set_file_contents(<<~EOF)
|
|
foo = bar( "one", "two" )
|
|
EOF
|
|
|
|
vim.search('one')
|
|
split
|
|
|
|
assert_file_contents(<<~EOF)
|
|
foo = bar(
|
|
"one",
|
|
"two"
|
|
)
|
|
EOF
|
|
end
|
|
|
|
specify "with a trailing comma" do
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
vim.command('let g:splitjoin_trailing_comma = 1')
|
|
|
|
set_file_contents(<<~EOF)
|
|
foo = bar("one", "two")
|
|
EOF
|
|
|
|
vim.search('one')
|
|
split
|
|
|
|
assert_file_contents(<<~EOF)
|
|
foo = bar(
|
|
"one",
|
|
"two",
|
|
)
|
|
EOF
|
|
end
|
|
|
|
specify "don't split keywords" do
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
|
|
set_file_contents(<<~EOF)
|
|
foo = case value
|
|
end
|
|
EOF
|
|
|
|
vim.search('case')
|
|
split
|
|
|
|
assert_file_contents(<<~EOF)
|
|
foo = case value
|
|
end
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "method options" do
|
|
specify "with curly braces" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 1')
|
|
|
|
set_file_contents <<~EOF
|
|
foo 1, 2, :one => 1, :two => 2
|
|
EOF
|
|
|
|
vim.search(':one')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo 1, 2, {
|
|
:one => 1,
|
|
:two => 2
|
|
}
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo 1, 2, { :one => 1, :two => 2 }
|
|
EOF
|
|
end
|
|
|
|
specify "without curly braces" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 0')
|
|
|
|
set_file_contents <<~EOF
|
|
foo 1, 2, :one => 1, :two => 2
|
|
EOF
|
|
|
|
vim.search(':one')
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo 1, 2,
|
|
:one => 1,
|
|
:two => 2
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo 1, 2, :one => 1, :two => 2
|
|
EOF
|
|
end
|
|
|
|
specify "with round braces" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 0')
|
|
|
|
set_file_contents <<~EOF
|
|
foo(:one => 1, :two => 2)
|
|
EOF
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo(:one => 1,
|
|
:two => 2)
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo(:one => 1, :two => 2)
|
|
EOF
|
|
end
|
|
|
|
specify "with arguments, round braces, curly braces" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 1')
|
|
|
|
set_file_contents <<~EOF
|
|
foo(one, :two => 2, :three => 3)
|
|
EOF
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo(one, {
|
|
:two => 2,
|
|
:three => 3
|
|
})
|
|
EOF
|
|
end
|
|
|
|
specify "no arguments, round braces, no curly braces, no hanging" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 0')
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
|
|
set_file_contents <<~EOF
|
|
OpenStruct.new(first_name: 'John', last_name: 'Doe', age: 50)
|
|
EOF
|
|
|
|
vim.search 'first_name'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
OpenStruct.new(
|
|
first_name: 'John',
|
|
last_name: 'Doe',
|
|
age: 50
|
|
)
|
|
EOF
|
|
end
|
|
|
|
specify "arguments, round braces, no curly braces, no hanging" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 0')
|
|
vim.command('let g:splitjoin_ruby_hanging_args = 0')
|
|
|
|
set_file_contents <<~EOF
|
|
OpenStruct.new(one, {first_name: 'John', last_name: 'Doe', age: 50})
|
|
EOF
|
|
|
|
vim.search 'first_name'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
OpenStruct.new(
|
|
one,
|
|
first_name: 'John',
|
|
last_name: 'Doe',
|
|
age: 50
|
|
)
|
|
EOF
|
|
end
|
|
|
|
specify "join hanging hash options" do
|
|
set_file_contents <<~EOF
|
|
OpenStruct.new(one,
|
|
first_name: 'John',
|
|
last_name: 'Doe',
|
|
age: 50)
|
|
EOF
|
|
|
|
vim.search('one')
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
OpenStruct.new(one, first_name: 'John', last_name: 'Doe', age: 50)
|
|
EOF
|
|
end
|
|
|
|
specify "split options as arguments" do
|
|
vim.command('let g:splitjoin_ruby_options_as_arguments = 1')
|
|
|
|
set_file_contents <<~EOF
|
|
OpenStruct.new(one, two, {first_name: 'John', last_name: 'Doe'})
|
|
EOF
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
OpenStruct.new(one,
|
|
two,
|
|
first_name: 'John',
|
|
last_name: 'Doe')
|
|
EOF
|
|
|
|
set_file_contents <<~EOF
|
|
OpenStruct.new(one, two, {first_name: 'John', last_name: 'Doe'})
|
|
EOF
|
|
|
|
vim.search 'first_name'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
OpenStruct.new(one, two, {
|
|
first_name: 'John',
|
|
last_name: 'Doe'
|
|
})
|
|
EOF
|
|
end
|
|
|
|
specify "doesn't get confused by interpolation" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 1')
|
|
|
|
set_file_contents <<~EOF
|
|
foo "\#{one}", :two => 3
|
|
EOF
|
|
|
|
vim.search ':two'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo "\#{one}", {
|
|
:two => 3
|
|
}
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo "\#{one}", { :two => 3 }
|
|
EOF
|
|
end
|
|
|
|
specify "doesn't get confused by namespaces (::)" do
|
|
vim.command('let g:splitjoin_ruby_curly_braces = 1')
|
|
|
|
set_file_contents <<~EOF
|
|
foo Bar::Baz, bla
|
|
EOF
|
|
|
|
vim.search 'Bar'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo(Bar::Baz,
|
|
bla)
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
foo(Bar::Baz, bla)
|
|
EOF
|
|
end
|
|
|
|
specify "doesn't get confused by extra spaces" do
|
|
set_file_contents <<~EOF
|
|
rules << { query: escaped_query }
|
|
EOF
|
|
|
|
vim.search 'query'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
rules << {
|
|
query: escaped_query
|
|
}
|
|
EOF
|
|
end
|
|
|
|
specify "[edge case] finds a function around the cursor, not after" do
|
|
set_file_contents <<~EOF
|
|
foo :one, :two => (true || false || foo(bar, baz))
|
|
EOF
|
|
|
|
vim.search ':one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
foo :one, {
|
|
:two => (true || false || foo(bar, baz))
|
|
}
|
|
EOF
|
|
end
|
|
|
|
specify "[edge case] block after a list of arguments" do
|
|
set_file_contents <<~EOF
|
|
function_call(one, two) { bar }
|
|
EOF
|
|
|
|
vim.search 'function_call'
|
|
split
|
|
|
|
# Unchanged
|
|
assert_file_contents <<~EOF
|
|
function_call(one, two) { bar }
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "arrays" do
|
|
specify "simple case" do
|
|
set_file_contents "array = ['one', 'two', 'three']"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = [
|
|
'one',
|
|
'two',
|
|
'three'
|
|
]
|
|
EOF
|
|
|
|
vim.search 'array ='
|
|
join
|
|
|
|
assert_file_contents "array = ['one', 'two', 'three']"
|
|
end
|
|
|
|
specify "multiple lines join case" do
|
|
set_file_contents <<~EOF
|
|
array = [
|
|
'one', 'two', 'three',
|
|
'four', 'five', 'six'
|
|
]
|
|
EOF
|
|
|
|
vim.search '= ['
|
|
join
|
|
|
|
vim.search 'array ='
|
|
assert_file_contents "array = ['one', 'two', 'three', 'four', 'five', 'six']"
|
|
end
|
|
|
|
specify "single indent join case" do
|
|
set_file_contents <<~EOF
|
|
array = ['one', 'two', 'three',
|
|
'four', 'five', 'six']
|
|
EOF
|
|
|
|
vim.search '= ['
|
|
join
|
|
|
|
vim.search 'array ='
|
|
assert_file_contents "array = ['one', 'two', 'three', 'four', 'five', 'six']"
|
|
end
|
|
|
|
specify "only works within the actual array" do
|
|
set_file_contents <<~EOF
|
|
before { forked_project.team << [project.creator, :developer] }
|
|
EOF
|
|
|
|
vim.search 'forked_project'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
before do
|
|
forked_project.team << [project.creator, :developer]
|
|
end
|
|
EOF
|
|
end
|
|
|
|
specify "last hash inside array doesn't disappear" do
|
|
set_file_contents "array = [0, { a: 1 }]"
|
|
|
|
vim.search '0'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = [
|
|
0,
|
|
{ a: 1 }
|
|
]
|
|
EOF
|
|
|
|
vim.search 'array ='
|
|
join
|
|
|
|
assert_file_contents "array = [0, { a: 1 }]"
|
|
end
|
|
|
|
specify "last hash inside array can be expanded" do
|
|
vim.command('let g:splitjoin_ruby_expand_options_in_arrays = 1')
|
|
set_file_contents "array = [0, { a: 1 }]"
|
|
|
|
vim.search '0'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = [
|
|
0,
|
|
a: 1
|
|
]
|
|
EOF
|
|
|
|
vim.search 'array ='
|
|
join
|
|
|
|
assert_file_contents "array = [0, a: 1]"
|
|
end
|
|
|
|
specify "last hash inside array can also be bracketless" do
|
|
set_file_contents "array = [0, a: 1]"
|
|
|
|
vim.search '0'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = [
|
|
0,
|
|
a: 1
|
|
]
|
|
EOF
|
|
|
|
vim.search 'array ='
|
|
join
|
|
|
|
assert_file_contents "array = [0, a: 1]"
|
|
end
|
|
end
|
|
|
|
describe "string array literals" do
|
|
specify "simple case with {" do
|
|
set_file_contents "array = %w{one two three}"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %w{
|
|
one
|
|
two
|
|
three
|
|
}
|
|
EOF
|
|
|
|
vim.search '%w{'
|
|
join
|
|
|
|
assert_file_contents "array = %w{one two three}"
|
|
end
|
|
|
|
specify "simple case with |" do
|
|
set_file_contents "array = %w|one two three|"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %w|
|
|
one
|
|
two
|
|
three
|
|
|
|
|
EOF
|
|
|
|
vim.search '%w|'
|
|
join
|
|
|
|
assert_file_contents "array = %w|one two three|"
|
|
end
|
|
|
|
specify "simple case with (" do
|
|
set_file_contents "array = %w(one two three)"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %w(
|
|
one
|
|
two
|
|
three
|
|
)
|
|
EOF
|
|
|
|
vim.search '%w('
|
|
join
|
|
|
|
assert_file_contents "array = %w(one two three)"
|
|
end
|
|
|
|
specify "simple case with [" do
|
|
set_file_contents "array = %w[one two three]"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %w[
|
|
one
|
|
two
|
|
three
|
|
]
|
|
EOF
|
|
|
|
vim.search '%w['
|
|
join
|
|
|
|
assert_file_contents "array = %w[one two three]"
|
|
end
|
|
end
|
|
|
|
describe "symbol array literals" do
|
|
specify "simple case with {" do
|
|
set_file_contents "array = %i{one two three}"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %i{
|
|
one
|
|
two
|
|
three
|
|
}
|
|
EOF
|
|
|
|
vim.search '%i{'
|
|
join
|
|
|
|
assert_file_contents "array = %i{one two three}"
|
|
end
|
|
|
|
specify "simple case with |" do
|
|
set_file_contents "array = %i|one two three|"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %i|
|
|
one
|
|
two
|
|
three
|
|
|
|
|
EOF
|
|
|
|
vim.search '%i|'
|
|
join
|
|
|
|
assert_file_contents "array = %i|one two three|"
|
|
end
|
|
|
|
specify "simple case with (" do
|
|
set_file_contents "array = %i(one two three)"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %i(
|
|
one
|
|
two
|
|
three
|
|
)
|
|
EOF
|
|
|
|
vim.search '%i('
|
|
join
|
|
|
|
assert_file_contents "array = %i(one two three)"
|
|
end
|
|
|
|
specify "simple case with [" do
|
|
set_file_contents "array = %i[one two three]"
|
|
|
|
vim.search 'one'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
array = %i[
|
|
one
|
|
two
|
|
three
|
|
]
|
|
EOF
|
|
|
|
vim.search '%i['
|
|
join
|
|
|
|
assert_file_contents "array = %i[one two three]"
|
|
end
|
|
end
|
|
|
|
describe "method calls" do
|
|
specify "joining with a trailing dot" do
|
|
set_file_contents <<~EOF
|
|
one.
|
|
two.
|
|
three
|
|
EOF
|
|
|
|
vim.search 'one'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
one.two.three
|
|
EOF
|
|
end
|
|
|
|
specify "joining with a leading dot" do
|
|
set_file_contents <<~EOF
|
|
one
|
|
.two
|
|
.three
|
|
EOF
|
|
|
|
vim.search 'one'
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
one.two.three
|
|
EOF
|
|
end
|
|
end
|
|
|
|
describe "oneline method definitions" do
|
|
specify "with the cursor on the definition" do
|
|
set_file_contents <<~EOF
|
|
def foo(one, two) = bar
|
|
EOF
|
|
|
|
vim.search 'def'
|
|
split
|
|
|
|
assert_file_contents <<~EOF
|
|
def foo(one, two)
|
|
bar
|
|
end
|
|
EOF
|
|
|
|
join
|
|
|
|
assert_file_contents <<~EOF
|
|
def foo(one, two) = bar
|
|
EOF
|
|
end
|
|
end
|
|
end
|