seeing_is_believing 3.0.0.beta.4 → 3.0.0.beta.5

data/spec/seeing_is_believing_spec.rb

@@ -20,13 +20,18 @@ RSpec.describe SeeingIsBelieving do
       options.delete :debug
       options[:debugger] = SeeingIsBelieving::Debugger.new(stream: $stderr, colour: true)
     end
-    described_class.new(input, options).call
+    described_class.new(input, options).call.result
   end
 
   def values_for(input, options={})
     invoke(input, options).to_a
   end
 
+  root_path       = File.expand_path("../..", __FILE__)
+  proving_grounds = File.expand_path('proving_grounds', root_path)
+  before(:all) { Dir.mkdir proving_grounds unless Dir.exist? proving_grounds }
+  around { |spec| Dir.chdir proving_grounds, &spec }
+
   let(:proving_grounds_dir) { File.expand_path '../../proving_grounds', __FILE__ }
 
   it 'takes a string and returns a result of the line numbers (counting from 1) and each inspected result from that line' do
@@ -35,6 +40,10 @@ RSpec.describe SeeingIsBelieving do
     expect(invoke(input)[2]).to eq ['"22"']
   end
 
+  it 'blows up if given unknown options' do
+    expect { invoke '', not_an_option: 123 }.to raise_error KeyError, /not_an_option/
+  end
+
   it 'only invokes inspect once' do
     input = "class Fixnum; def inspect; 'NUM'\nend\nend\n1"
     expect(invoke(input)[1]).to eq ['"NUM"']
@@ -45,10 +54,10 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'records various useful information on the result' do
-    result = invoke '', number_of_captures: 10, filename: 'abc.rb'
+    result = invoke '', max_line_captures: 10, filename: 'abc.rb'
     expect(result.sib_version).to eq SeeingIsBelieving::VERSION
     expect(result.ruby_version).to eq RUBY_VERSION
-    expect(result.number_of_captures).to eq 10 # TODO: rename to max_captures_per_line ?? (also max_line_captures would prob get renamed if we do this)
+    expect(result.max_line_captures).to eq 10
     expect(result.num_lines).to eq 1
     expect(result.filename).to eq 'abc.rb'
   end
@@ -58,14 +67,12 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'allows uers to pass in their own inspection recorder' do
-    wrapper = lambda { |program, filename, num_captures|
-      SeeingIsBelieving::InspectExpressions.call \
-        program,
-        filename,
-        num_captures,
-        after_each: -> line_number { ").tap { $SiB.record_result(:inspect, #{line_number}, 'zomg') }" }
+    wrapper = lambda { |program|
+      SeeingIsBelieving::WrapExpressions.call program,
+        before_each: -> * { '(' },
+        after_each:  -> line_number { ").tap { $SiB.record_result(:inspect, #{line_number}, 'zomg') }" }
     }
-    expect(invoke(':body', record_expressions: wrapper)[1]).to eq ['"zomg"']
+    expect(invoke(':body', rewrite_code: wrapper)[1]).to eq ['"zomg"']
   end
 
   it 'remembers context of previous lines' do
@@ -74,8 +81,8 @@ RSpec.describe SeeingIsBelieving do
 
   it 'can be invoked multiple times, returning the same result' do
     believer = described_class.new("$xyz||=1\n$xyz+=1")
-    expect(believer.call.to_a).to eq [['1'], ['2']]
-    expect(believer.call.to_a).to eq [['1'], ['2']]
+    expect(believer.call).to eq believer.call
+    expect(believer.call.result.to_a).to eq [['1'], ['2']]
   end
 
   it 'is evaluated at the toplevel' do
@@ -179,7 +186,24 @@ RSpec.describe SeeingIsBelieving do
     end
   end
 
+  it 'supports catch/throw' do
+    values = values_for("catch :zomg do\n"\
+                        "  1\n"\
+                        "  throw :zomg\n"\
+                        "  2\n"\
+                        "end")
+    expect(values).to eq [[], ['1'], [], [], ['nil']]
 
+    result = invoke("throw :zomg")
+    expect(result.exception.message).to match /:zomg/
+  end
+
+  it 'does not fuck up the __ENCODING__ macro' do
+    expect(values_for("# encoding: utf-8
+                      __ENCODING__")).to eq [[], ["#<Encoding:UTF-8>"]]
+    expect(values_for("# encoding: ascii-8bit
+                      __ENCODING__")).to eq [[], ["#<Encoding:ASCII-8BIT>"]]
+  end
 
   it 'does not fuck up __LINE__ macro' do
     expect(values_for( '__LINE__
@@ -314,7 +338,7 @@ RSpec.describe SeeingIsBelieving do
   it 'can deal with methods that are invoked entirely on the next line' do
     expect(values_for("a = 1\n.even?\na")).to eq [['1'], ['false'], ['false']]
     expect(values_for("a = 1.\neven?\na")).to eq [['1'], ['false'], ['false']]
-    expect(values_for("1\n.even?\n__END__")).to eq [['1'], ['false'], []] # TODO: would be nice if we could consolidate this shit so we could find out things like __END__ without repeatedly parsing, I'd prefer if this did not imply there were results on this line -.-
+    expect(values_for("1\n.even?\n__END__")).to eq [['1'], ['false'], []]
   end
 
   it 'does not record leading comments' do
@@ -325,15 +349,35 @@ RSpec.describe SeeingIsBelieving do
   end
 
   it 'times out if the timeout limit is exceeded' do
-    expect { invoke "sleep 0.2", timeout: 0.1 }.to raise_error Timeout::Error
+    expect { invoke "sleep 0.2", timeout_seconds: 0.1 }.to raise_error Timeout::Error
   end
 
   it 'records the exit status' do
-    expect(invoke('raise "omg"').exitstatus).to eq 1
-    expect(invoke('exit 123').exitstatus).to eq 123
-    expect(invoke('at_exit { exit 121 }').exitstatus).to eq 121
+    expect(invoke(""                    ).exitstatus).to eq 0   # happy path: no exceptions
+    expect(invoke('raise "omg"'         ).exitstatus).to eq 1   # exceptions: status is 1
+    expect(invoke('exit'                ).exitstatus).to eq 0   # call exit, but with no args
+    expect(invoke('exit 0'              ).exitstatus).to eq 0   # set numeric status with exit
+    expect(invoke('exit 123'            ).exitstatus).to eq 123
+    expect(invoke('exit true'           ).exitstatus).to eq 0   # set boolean status with exit
+    expect(invoke('exit false'          ).exitstatus).to eq 1
+    expect(invoke('at_exit { exit 121 }').exitstatus).to eq 121 # when status is set in an at_exit hook
+
+    # setting status with exit!
+    # since we might be overriding this (a questionable decision) we make sure it behaves as expected (no at_exit hooks are called)
+    result = invoke 'at_exit { puts "omg" }; exit!'
+    expect([result.exitstatus, result.stdout, result.stderr]).to eq [1, '', '']
+
+    result = invoke 'at_exit { puts "omg" }; exit! 100'
+    expect([result.exitstatus, result.stdout]).to eq [100, '']
+
+    result = invoke 'at_exit { puts "omg" }; Kernel.exit! 101'
+    expect([result.exitstatus, result.stdout]).to eq [101, '']
+
+    result = invoke 'at_exit { puts "omg" }; Kernel.exit! 102'
+    expect([result.exitstatus, result.stdout]).to eq [102, '']
   end
 
+
   it 'records lines that have comments on them' do
     expect(values_for('1+1 # comment uno
                       #comment dos
@@ -373,23 +417,28 @@ RSpec.describe SeeingIsBelieving do
                                                         ['[6, 12]']]
   end
 
-  it 'can be limited to a specific number of captures' do
-    expect(values_for "2.times do\n1\nend", number_of_captures: 1).to \
+  it 'can be limited to a specific number of captures per line' do
+    expect(values_for "2.times do\n1\nend", max_line_captures: 1).to \
       eq [['2'],
           ['1', '...'],
           ['2']]
   end
 
   describe 'BEGIN and END' do
+    it 'doesn\'t fuck up when the BEGIN block exits / raises' do
+      expect(invoke("BEGIN { exit 100 }").exitstatus).to eq 100
+      expect(invoke("BEGIN { exit! 100 }").exitstatus).to eq 100
+      expect(invoke("BEGIN { raise Exception, 'wat'}").exception.message).to eq 'wat'
+    end
+
     it 'Executes in the appropriate order' do
-      pending 'not implemented'
-      expect(invoke <<-CODE).stdout.to eq "1\n2\n3\n4\n5\n6\n7\n8\n9\n"
+      expect(invoke(<<-CODE).stdout).to eq "1\n2\n3\n4\n5\n6\n7\n8\n9\n"
         p 3
-        END   { p 8 }
+        END   { p 9 }
         p 4
         BEGIN { p 1 }
         p 5
-        END   { p 9 }
+        END   { p 8 }
         p 6
         BEGIN { p 2 }
         p 7
@@ -397,7 +446,6 @@ RSpec.describe SeeingIsBelieving do
     end
 
     it 'Maintains correct line numbers' do
-      pending 'not implemented'
       expected_values = [
         ['1'],
         [],
@@ -434,7 +482,7 @@ RSpec.describe SeeingIsBelieving do
     result = invoke(%[def self.inspect
                         self
                       end
-                      self], filename: 'blowsup.rb') # TODO This actually writes the file into the root of SiB
+                      self], filename: 'blowsup.rb')
     expect(result).to have_exception
     expect(result.exception.class_name).to eq 'SystemStackError'
     expect(result.exception.backtrace.grep(/blowsup.rb/)).to_not be_empty # backtrace includes a line that we can show
@@ -454,34 +502,48 @@ RSpec.describe SeeingIsBelieving do
     let(:debugger) { SeeingIsBelieving::Debugger.new stream: stream }
 
     def call
-      invoke "1", debugger: debugger
+      result = invoke "1", debugger: debugger
+      expect(result[1]).to eq ["1"]
+      result
     end
 
     it 'prints the pre-evaluated program' do
       call
-      expect(stream.string).to include "TRANSLATED PROGRAM:"
-      expect(stream.string).to include "$SiB.num_lines" # there is more, but we're just interested in showing that it wound up in the stream
+      expect(stream.string).to include "REWRITTEN PROGRAM:"
+      expect(stream.string).to include "$SiB.record_result" # there is more, but we're just interested in showing that it wound up in the stream
     end
 
-    it 'prints the result' do
+    it 'records eventstream information' do
       call
-      expect(stream.string).to include "RESULT:"
-      expect(stream.string).to include 'SIB::Result'
-      expect(stream.string).to include '@results={'
+      expect(stream.string).to include "EVENTS"
+    end
+  end
+
+  describe 'exec' do
+    it 'passes stdin, stdout, stderr, and actually does exec the process' do
+      result = invoke \
+        "1+1\n"\
+        "$stdout.puts *1..1000\n"\
+        "$stderr.puts *1..1000\n"\
+        "exec %(ruby -e '$stdout.puts %{from stdin: } + gets.inspect
+                         $stdout.puts %[out from exec]
+                         $stderr.puts %[err from exec]')\n"\
+        "$stdout.puts 'this will never be executed'",
+         stdin: "the-stdin-dataz"
+      expect(result[1]).to eq ['2']
+      nums = (1..1000).map { |n| "#{n}\n" }.join('')
+      expect(result.stdout).to eq "#{nums}from stdin: \"the-stdin-dataz\"\nout from exec\n"
+      expect(result.stderr).to eq "#{nums}err from exec\n"
+    end
+
+    it 'works for Kernel#exec, Kernel.exec, Process.exec' do
+      expect(invoke('exec "ruby", "-e", "puts %(hello)"').stdout).to eq "hello\n"
+      expect(invoke('Kernel.exec "ruby", "-e", "puts %(hello)"').stdout).to eq "hello\n"
+      expect(invoke('Process.exec "ruby", "-e", "puts %(hello)"').stdout).to eq "hello\n"
+    end
+
+    it 'gets the exit status off of the child process' do
+      expect(invoke('exec "ruby", "-e", "exit 5"').exitstatus).to eq 5
     end
-    # should ProgramRewriter have some debug options?
-  end
-
-  it 'can deal with exec' do
-    result = invoke \
-      "1+1\n"\
-      "$stdout.puts *1..1000\n"\
-      "$stderr.puts *1..1000\n"\
-      "exec %(ruby -e '$stdout.puts %[out from exec];
-                       $stderr.puts %[err from exec]')"
-    expect(result[1]).to eq ['2']
-    nums = (1..1000).map { |n| "#{n}\n" }.join('')
-    expect(result.stdout).to eq "#{nums}out from exec\n"
-    expect(result.stderr).to eq "#{nums}err from exec\n"
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,12 @@
+module SibSpecHelpers
+  def pending!(message="Not yet implemented")
+    pending message
+    raise message
+  end
+end
+
 RSpec.configure do |c|
   c.disable_monkey_patching!
+  c.include SibSpecHelpers
+  c.filter_run_excluding :not_implemented
 end

data/spec/wrap_expressions_spec.rb

@@ -2,12 +2,29 @@ require 'spec_helper'
 require 'seeing_is_believing/wrap_expressions'
 
 RSpec.describe SeeingIsBelieving::WrapExpressions do
-  def wrap(code)
-    described_class.call code,
-      before_each: -> * { '<' },
-      after_each:  -> * { '>' }
+  def wrap(code, overrides={})
+    code = code + "\n" unless code.end_with? "\n"
+    described_class.call(code,
+      before_all:  ->   { overrides.fetch :before_all,   '' },
+      after_all:   ->   { overrides.fetch :after_all,    '' },
+      before_each: -> * { overrides.fetch :before_each, '<' },
+      after_each:  -> * { overrides.fetch :after_each,  '>' }
+    ).chomp
   end
 
+  def wrap_with_body(code, overrides={})
+    wrap code, { before_all: '[',
+                 after_all:  ']',
+               }.merge(overrides)
+  end
+
+  def heredoc_wrap(code, overrides={})
+    wrap_with_body code, { before_each: '{'.freeze,
+                           after_each:  '}'.freeze,
+                         }.merge(overrides)
+  end
+
+
   it 'raises a SyntaxError if the program is invalid' do
     expect { wrap '+' }.to raise_error SyntaxError
   end
@@ -17,34 +34,31 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
   end
 
   describe 'wrapping the body' do
-    let(:options) { { before_all:  ->   { "[".freeze },
-                      after_all:   ->   { "]".freeze },
-                      before_each: -> * { '<'.freeze },
-                      after_each:  -> * { '>'.freeze } } }
-
     it 'wraps the entire body, ignoring leading comments and the data segment' do
-      expect(described_class.call("#comment\nA\n__END__\n1", options)).to eq "#comment\n[<A>]\n__END__\n1"
+      expect(wrap_with_body "#comment\nA\n__END__\n1").to eq "#comment\n[<A>]\n__END__\n1"
+      expect(wrap_with_body "#comment\n__END__\n1").to eq "[]#comment\n__END__\n1"
     end
 
-    it 'comes in on blank lines' do
-      expect(described_class.call('', options)).to eq '[]'
+    it 'wraps when code is an empty string' do
+      expect(wrap_with_body '').to eq '[]'
     end
 
-    it 'comes in first when there are only comments' do
-      expect(described_class.call("# abc", options)).to eq "[]# abc"
+    it 'places body before first comment when there are only comments' do
+      expect(wrap_with_body "# abc").to eq "[]# abc"
     end
 
-    it 'comes in before trailing comments' do
-      expect(described_class.call("1# abc", options)).to eq "[<1>]# abc"
+    it 'places body before trailing comments, but still wraps code' do
+      expect(wrap_with_body "1# abc").to eq "[<1>]# abc"
     end
 
     # this changes the number of lines, annoyingly, though it shouldn't mess anything up,
     # unless you were trying to reopen the file to read it, in which case, *surprise* the whole thing's been rewritten
     it 'injects a newline if there is a data segment and the after block doesn\'t end in a newline' do
-      expect(described_class.call("__END__", options)).to eq "[]\n__END__"
-      expect(described_class.call("\n__END__", options)).to eq "[]\n__END__"
-      expect(described_class.call("\n\n__END__", options)).to eq "[]\n\n__END__"
-      expect(described_class.call("__END__!", options)).to eq "[<__END__!>]"
+      expect(wrap_with_body "__END__").to eq "[]\n__END__"
+      expect(wrap_with_body "\n__END__").to eq "[]\n__END__"
+      expect(wrap_with_body "\n\n__END__").to eq "[]\n\n__END__"
+      expect(wrap_with_body "__END__!").to eq "[<__END__!>]"
+      expect(wrap_with_body "%(\n__END__\n)").to eq "[<%(\n__END__\n)>]"
     end
 
     it 'wraps bodies that are wrapped in parentheses' do
@@ -54,35 +68,28 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
 
     context 'fucking heredocs' do
       example 'single heredoc' do
-        expect(described_class.call("<<A\nA", options)).to eq "[<<<A>]\nA"
+        expect(heredoc_wrap "<<A\nA").to eq "[{<<A}]\nA"
       end
 
       example 'multiple heredocs' do
-        # a stupid implementation issue from hacking around heredocs
-        # causes the toplevel begin to wrap the whole file.
-        # It's fine b/c it is ultimately the same, but that's why it's
-        # "[<<<<A>\nA\n<<B>]\nB"
-        # instead of
-        # "[<<<A>\nA\n<<<B>]\nB"
-        expect(described_class.call("<<A\nA\n<<B\nB", options)).to eq "[<<<<A>\nA\n<<B>]\nB"
+        expect(heredoc_wrap "<<A\nA\n<<B\nB").to eq "[{<<A}\nA\n{<<B}]\nB"
       end
 
       example 'heredocs as targets and arguments to methods' do
-        expect(described_class.call("<<A.size 1\nA", options)).to eq "[<<<A.size 1>]\nA"
-        expect(described_class.call("<<A.size\nA", options)).to eq "[<<<A.size>]\nA"
-        expect(described_class.call("<<A.size()\nA", options)).to eq "[<<<A.size()>]\nA"
-        expect(described_class.call("a.size <<A\nA", options)).to eq "[<a.size <<A>]\nA"
-        expect(described_class.call("<<A.size <<B\nA\nB", options)).to eq "[<<<A.size <<B>]\nA\nB"
-        expect(described_class.call("<<A.size(<<B)\nA\nB", options)).to eq "[<<<A.size(<<B)>]\nA\nB"
+        expect(heredoc_wrap "<<A.size 1\nA").to eq "[{<<A.size 1}]\nA"
+        expect(heredoc_wrap "<<A.size\nA").to eq "[{<<A.size}]\nA"
+        expect(heredoc_wrap "<<A.size()\nA").to eq "[{<<A.size()}]\nA"
+        expect(heredoc_wrap "a.size <<A\nA").to eq "[{a.size <<A}]\nA"
+        expect(heredoc_wrap "<<A.size <<B\nA\nB").to eq "[{<<A.size <<B}]\nA\nB"
+        expect(heredoc_wrap "<<A.size(<<B)\nA\nB").to eq "[{<<A.size(<<B)}]\nA\nB"
       end
     end
 
     it 'identifies the last line of the body' do
-      expect(described_class.call("a\n"\
-                                  "def b\n"\
-                                  "  c = 1\n"\
-                                  "end",
-                                  options)
+      expect(wrap_with_body "a\n"\
+                            "def b\n"\
+                            "  c = 1\n"\
+                            "end"
             ).to eq "[<a>\n"\
                     "<def b\n"\
                     "  <c = 1>\n"\
@@ -92,7 +99,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
 
   it 'passes the current line number to the before_each and after_each wrappers' do
     pre_line_num = post_line_num = nil
-    described_class.call("\na",
+    described_class.call("\na\n",
                          before_each: -> _pre_line_num  { pre_line_num  = _pre_line_num;  '<' },
                          after_each:  -> _post_line_num { post_line_num = _post_line_num; '>' }
                         )
@@ -101,8 +108,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
   end
 
   it 'does nothing for an empty program' do
-    expect(wrap("")).to eq ""
-    expect(wrap("\n")).to eq "\n"
+    expect(wrap("")).to eq "" # note that code will fix the missing newline, and wrap will chomp it from the result for convenience
   end
 
   it 'ignores comments' do
@@ -112,79 +118,6 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     expect(wrap "=begin\n1\n=end\n2").to eq "=begin\n1\n=end\n<2>"
   end
 
-  describe 'void value expressions' do
-    def void_value?(ast)
-      klass = described_class.new '', {}
-      klass.__send__(:void_value?, ast)
-    end
-
-    def ast_for(code)
-      Parser::CurrentRuby.parse code
-    end
-
-    it 'knows a `return`, `next`, `redo`, `retry`, and `break` are void values' do
-      expect(void_value?(ast_for("def a; return; end").children.last)).to be true
-      expect(void_value?(ast_for("loop { next  }"    ).children.last)).to be true
-      expect(void_value?(ast_for("loop { redo  }"    ).children.last)).to be true
-      expect(void_value?(ast_for("loop { break }"    ).children.last)).to be true
-
-      the_retry = ast_for("begin; rescue; retry; end").children.first.children[1].children.last
-      expect(the_retry.type).to eq :retry
-      expect(void_value? the_retry).to eq true
-    end
-    it 'knows an `if` is a void value if either side is a void value' do
-      the_if = ast_for("def a; if 1; return 2; else; 3; end; end").children.last
-      expect(the_if.type).to eq :if
-      expect(void_value?(the_if)).to be true
-
-      the_if = ast_for("def a; if 1; 2; else; return 3; end; end").children.last
-      expect(the_if.type).to eq :if
-      expect(void_value?(the_if)).to be true
-
-      the_if = ast_for("def a; if 1; 2; else; 3; end; end").children.last
-      expect(the_if.type).to eq :if
-      expect(void_value?(the_if)).to be false
-    end
-    it 'knows a begin is a void value if its last element is a void value' do
-      the_begin = ast_for("loop { begin; break; end }").children.last
-      expect([:begin, :kwbegin]).to include the_begin.type
-      expect(void_value?(the_begin)).to be true
-
-      the_begin = ast_for("loop { begin; 1; end }").children.last
-      expect([:begin, :kwbegin]).to include the_begin.type
-      expect(void_value?(the_begin)).to be false
-    end
-    it 'knows a rescue is a void value if its last child or its else is a void value' do
-      the_rescue = ast_for("begin; rescue; retry; end").children.first
-      expect(the_rescue.type).to eq :rescue
-      expect(void_value?(the_rescue)).to be true
-
-      the_rescue = ast_for("begin; rescue; 1; else; retry; end").children.first
-      expect(the_rescue.type).to eq :rescue
-      expect(void_value?(the_rescue)).to be true
-
-      the_rescue = ast_for("begin; rescue; 1; else; 2; end").children.first
-      expect(the_rescue.type).to eq :rescue
-      expect(void_value?(the_rescue)).to be false
-    end
-    it 'knows an ensure is a void value if its body or ensure portion are void values' do
-      the_ensure = ast_for("loop { begin; break; ensure; 1; end }").children.last.children.last
-      expect(the_ensure.type).to eq :ensure
-      expect(void_value?(the_ensure)).to be true
-
-      the_ensure = ast_for("loop { begin; 1; ensure; break; end }").children.last.children.last
-      expect(the_ensure.type).to eq :ensure
-      expect(void_value?(the_ensure)).to be true
-
-      the_ensure = ast_for("loop { begin; 1; ensure; 2; end }").children.last.children.last
-      expect(the_ensure.type).to eq :ensure
-      expect(void_value?(the_ensure)).to be false
-    end
-    it 'knows other things are not void values' do
-      expect(void_value?(ast_for "123")).to be false
-    end
-  end
-
   describe 'basic expressions' do
     it 'wraps an expression' do
       expect(wrap("A")).to eq "<A>"
@@ -200,6 +133,10 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     it 'does not wrap multiple expressions when they constitute a void value' do
       expect(wrap("def a\n1\nreturn 2\nend")).to eq "<def a\n<1>\nreturn <2>\nend>"
       expect(wrap("def a\nreturn 1\n2\nend")).to eq "<def a\nreturn <1>\n<2>\nend>"
+      # BUG, but I'm skipping it, b/c it's borderline invalid.
+      # To the point that Parser doesn't even emit the else clause in the AST
+      # And Ruby will warn you that it's useless
+      # expect(wrap("begin\n1\nelse\nbreak\nend")).to eq "begin\n<1>\nelse\nbreak\nend"
     end
 
     it 'wraps nested expressions' do
@@ -212,9 +149,6 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
 
     # many of these taken from http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Literals
     it 'wraps simple literals' do
-      # should maybe also do %i[] and %I[] for symbols,
-      # but that's only Ruby 2.0, so I'm ignoring it for now
-      # (I expect it to handle them just fine)
       %w|123
          -123
          1_123
@@ -236,6 +170,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
          1...2
 
          (true==true)..(1==2)
+         (true==true)...(1==2)
 
          true
          false
@@ -268,16 +203,16 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     end
 
     it 'wraps macros' do
-      # should this actually replace __FILE__ and __LINE__ so as to avoid fucking up values with the rewrite?
-      # there is also __dir__, but it's only 2.0
       expect(wrap("__FILE__")).to eq "<__FILE__>"
       expect(wrap("__LINE__")).to eq "<__LINE__>"
+      expect(wrap("__ENCODING__")).to eq "<__ENCODING__>"
       expect(wrap("defined? a")).to eq "<defined? a>"
     end
 
     it 'does not wrap alias, undef' do
       expect(wrap("alias tos to_s")).to eq "alias tos to_s"
       expect(wrap("undef tos")).to eq "undef tos"
+      expect(wrap("alias $a $b")).to eq "alias $a $b"
     end
 
     it 'wraps syscalls, but not code interpolated into them' do
@@ -290,6 +225,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     it 'wraps them' do
       expect(wrap('a')).to eq "<a>"
       expect(wrap("$a")).to eq "<$a>"
+      expect(wrap("$1")).to eq "<$1>"
       expect(wrap("@a")).to eq "<@a>"
       expect(wrap("@@a")).to eq "<@@a>"
     end
@@ -311,6 +247,8 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("a { }")).to eq "<a { }>"
       expect(wrap("a {\n}")).to eq "<a {\n}>"
       expect(wrap("a(b) {\n}")).to eq "<a(b) {\n}>"
+      expect(wrap("a(&b\n)")).to eq "<a(&<b>\n)>"
+      expect(wrap("a(&lambda { }\n)")).to eq "<a(&<lambda { }>\n)>"
     end
 
     it 'wraps method calls with an explicit receiver' do
@@ -345,9 +283,9 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("a 1,\n2")).to eq "<a <1>,\n2>"
     end
 
-    it 'does not wrap splat args' do
-      expect(wrap("a(\n*a\n)")).to eq "<a(\n*a\n)>"
-      expect(wrap("a(\n*1..2\n)")).to eq "<a(\n*1..2\n)>"
+    it 'does wraps splat args' do
+      expect(wrap("a(\n*a\n)")).to eq "<a(\n*<a>\n)>"
+      expect(wrap("a(\n*1..2\n)")).to eq "<a(\n*<1..2>\n)>"
     end
 
     it 'does not wrap hash args' do
@@ -407,11 +345,13 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("a -= 1")).to eq "<a -= 1>"
       expect(wrap("a /= 1")).to eq "<a /= 1>"
       expect(wrap("a **= 1")).to eq "<a **= 1>"
+      expect(wrap("a != 1")).to eq "<a != 1>"
       expect(wrap("a |= 1")).to eq "<a |= 1>"
       expect(wrap("a &= 1")).to eq "<a &= 1>"
       expect(wrap("a ||= 1")).to eq "<a ||= 1>"
       expect(wrap("a &&= 1")).to eq "<a &&= 1>"
       expect(wrap("a[1] = 2")).to eq "<a[1] = 2>"
+      expect(wrap("a[1,2] = 3")).to eq "<a[1,2] = 3>"
       expect(wrap("a[1] ||= 2")).to eq "<a[1] ||= 2>"
       expect(wrap("@a  ||= 123")).to eq "<@a  ||= 123>"
       expect(wrap("$a  ||= 123")).to eq "<$a  ||= 123>"
@@ -444,6 +384,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("a,@b={\n},{\n}")).to eq "<a,@b=<{\n}>,{\n}>"
       expect(wrap("a,@@b={\n},{\n}")).to eq "<a,@@b=<{\n}>,{\n}>"
       expect(wrap("a,$b={\n},{\n}")).to eq "<a,$b=<{\n}>,{\n}>"
+      expect(wrap("a,$b={\n},{\n}")).to eq "<a,$b=<{\n}>,{\n}>"
 
       # repeated assignments
       expect(wrap("a=\nb={\n}")).to eq "<a=\nb={\n}>"
@@ -502,8 +443,9 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("1 if 2")).to eq "<1 if 2>"
     end
 
-    it 'ignores conditionals that are implicit regexes' do
-      expect(wrap("if /a/\n1\nend")).to eq "<if /a/\n<1>\nend>"
+    it 'wraps implicit regexes, retaining their magic behaviour by prepending a ~' do
+      expect(wrap("if /a/\n1\nend")).to eq "<if <~/a/>\n<1>\nend>"
+      expect(wrap("/a/ &&\n1")).to eq "<</a/> &&\n1>"
     end
 
     it 'wraps ternaries' do
@@ -545,6 +487,8 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     # not sure if I actually want this, or if it's just easier b/c it falls out of the current implementation
     it 'wraps the conditional from an inline if, when it cannot wrap the entire if' do
       expect(wrap("def a\nreturn if 1\nend")).to eq "<def a\nreturn if <1>\nend>"
+      # could maybe do this:
+      # `return 1 if b` -> `return <1> if (b) || <nil>`
     end
 
     it 'does not wrap &&, and, ||, or, not' do
@@ -567,15 +511,15 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("while 1\n2\nend")).to eq "<while <1>\n<2>\nend>"
       expect(wrap("1 while 2")).to eq "<1 while 2>"
       expect(wrap("begin\n1\nend while true")).to eq "<begin\n<1>\nend while true>"
+      expect(wrap("begin\n1\nend until true")).to eq "<begin\n<1>\nend until true>"
     end
     it 'wraps for/in loops collections and bodies' do
       expect(wrap("for a in range;1;end")).to eq "<for a in range;1;end>"
       expect(wrap("for a in range\n1\nend")).to eq "<for a in <range>\n<1>\nend>"
       expect(wrap("for a in range do\n1\nend")).to eq "<for a in <range> do\n<1>\nend>"
       expect(wrap("for a,b in whatev\n1\nend")).to eq "<for a,b in <whatev>\n<1>\nend>"
-      # this one just isn't worth it for now, too edge and I'm fucking tired
-      # wrap("for char in <<HERE.each_char\nabc\nHERE\nputs char\nend").should ==
-      #   "<for char in <<<HERE.each_char>\nabc\nHERE\n<puts char>\nend>"
+      expect(wrap("for char in <<HERE.each_char\nabc\nHERE\nputs char\nend"))
+        .to eq "<for char in <<<HERE.each_char>\nabc\nHERE\n<puts char>\nend>"
     end
     it 'does not wrap redo' do
       expect(wrap("loop do\nredo\nend")).to eq "<loop do\nredo\nend>"
@@ -596,6 +540,7 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     it 'wraps namespaced constant access' do
       expect(wrap("::A")).to eq "<::A>"
       expect(wrap("A::B")).to eq "<A::B>"
+      expect(wrap("a::B")).to eq "<a::B>"
     end
   end
 
@@ -618,8 +563,8 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("%w[\n1\n]")).to eq "<%w[\n1\n]>"
     end
 
-    it 'does not wrap splat elements' do
-      expect(wrap("[1,\n*2..3,\n4\n]")).to eq "<[<1>,\n*2..3,\n<4>\n]>"
+    it 'does wraps splat elements' do
+      expect(wrap("[1,\n*2..3,\n4\n]")).to eq "<[<1>,\n*<2..3>,\n<4>\n]>"
     end
   end
 
@@ -683,45 +628,46 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     end
 
     it 'wraps heredocs with call defined on them (edge cases on edge cases *sigh*)' do
-      expect(wrap("<<HERE.()\na\nHERE")).to eq "<<<HERE.()>\na\nHERE"
+      expect(heredoc_wrap "<<HERE.()\na\nHERE")
+        .to eq "[{<<HERE.()}]\na\nHERE"
     end
   end
 
   describe 'heredocs' do
     it 'wraps heredocs on their first line' do
-      expect(wrap("<<A\nA")).to eq "<<<A>\nA"
-      expect(wrap("<<A\n123\nA")).to eq "<<<A>\n123\nA"
-      expect(wrap("<<-A\nA")).to eq "<<<-A>\nA"
-      expect(wrap("<<-A\n123\nA")).to eq "<<<-A>\n123\nA"
-      expect(wrap("1\n<<A\nA")).to eq "<<1>\n<<A>\nA"
-      expect(wrap("<<A + <<B\n1\nA\n2\nB")).to eq "<<<A + <<B>\n1\nA\n2\nB"
-      expect(wrap("<<A\n1\nA\n<<B\n2\nB")).to eq "<<<<A>\n1\nA\n<<B>\n2\nB"
-      expect(wrap("puts <<A\nA\nputs <<B\nB")).to eq "<puts <<A>\nA\n<puts <<B>\nB"
+      expect(heredoc_wrap "<<A\nA").to eq "[{<<A}]\nA"
+      expect(heredoc_wrap "<<A\n123\nA").to eq "[{<<A}]\n123\nA"
+      expect(heredoc_wrap "<<-A\nA").to eq "[{<<-A}]\nA"
+      expect(heredoc_wrap "<<-A\n123\nA").to eq "[{<<-A}]\n123\nA"
+      expect(heredoc_wrap "1\n<<A\nA").to eq "[{1}\n{<<A}]\nA"
+      expect(heredoc_wrap "<<A + <<B\n1\nA\n2\nB").to eq "[{<<A + <<B}]\n1\nA\n2\nB"
+      expect(heredoc_wrap "<<A\n1\nA\n<<B\n2\nB").to eq "[{<<A}\n1\nA\n{<<B}]\n2\nB"
+      expect(heredoc_wrap "puts <<A\nA\nputs <<B\nB").to eq "[{puts <<A}\nA\n{puts <<B}]\nB"
     end
 
     it "wraps methods that wrap heredocs, even whent hey don't have parentheses" do
-      expect(wrap("a(<<HERE)\nHERE")).to eq "<a(<<HERE)>\nHERE"
-      expect(wrap("a <<HERE\nHERE")).to eq "<a <<HERE>\nHERE"
-      expect(wrap("a 1, <<HERE\nHERE")).to eq "<a 1, <<HERE>\nHERE"
-      expect(wrap("a.b 1, 2, <<HERE1, <<-HERE2 \nHERE1\n HERE2")).to eq\
-          "<a.b 1, 2, <<HERE1, <<-HERE2> \nHERE1\n HERE2"
-      expect(wrap("a.b 1,\n2,\n<<HERE\nHERE")).to eq "<a.b <1>,\n<2>,\n<<HERE>\nHERE"
+      expect(heredoc_wrap "a(<<HERE)\nHERE").to eq "[{a(<<HERE)}]\nHERE"
+      expect(heredoc_wrap "a <<HERE\nHERE").to eq "[{a <<HERE}]\nHERE"
+      expect(heredoc_wrap "a 1, <<HERE\nHERE").to eq "[{a 1, <<HERE}]\nHERE"
+      expect(heredoc_wrap "a.b 1, 2, <<HERE1, <<-HERE2 \nHERE1\n HERE2").to eq\
+          "[{a.b 1, 2, <<HERE1, <<-HERE2}] \nHERE1\n HERE2"
+      expect(heredoc_wrap "a.b 1,\n2,\n<<HERE\nHERE").to eq "[{a.b {1},\n{2},\n<<HERE}]\nHERE"
     end
 
     it "wraps assignments whose value is a heredoc" do
-      expect(wrap("a=<<A\nA")).to eq "<a=<<A>\nA"
-      expect(wrap("a,b=<<A,<<B\nA\nB")).to eq "<a,b=<<A,<<B>\nA\nB"
-      expect(wrap("a,b=1,<<B\nB")).to eq "<a,b=1,<<B>\nB"
-      expect(wrap("a,b=<<A,1\nA")).to eq "<a,b=<<A,1>\nA"
+      expect(heredoc_wrap "a=<<A\nA").to eq "[{a=<<A}]\nA"
+      expect(heredoc_wrap "a,b=<<A,<<B\nA\nB").to eq "[{a,b=<<A,<<B}]\nA\nB"
+      expect(heredoc_wrap "a,b=1,<<B\nB").to eq "[{a,b=1,<<B}]\nB"
+      expect(heredoc_wrap "a,b=<<A,1\nA").to eq "[{a,b=<<A,1}]\nA"
     end
 
     it 'wraps methods tacked onto the end of heredocs' do
-      expect(wrap("<<A.size\nA")).to eq "<<<A.size>\nA"
-      expect(wrap("<<A.size 1\nA")).to eq "<<<A.size 1>\nA"
-      expect(wrap("<<A.size(1)\nA")).to eq "<<<A.size(1)>\nA"
-      expect(wrap("<<A.whatever <<B\nA\nB")).to eq "<<<A.whatever <<B>\nA\nB"
-      expect(wrap("<<A.whatever(<<B)\nA\nB")).to eq "<<<A.whatever(<<B)>\nA\nB"
-      expect(wrap("<<A.size()\nA")).to eq "<<<A.size()>\nA"
+      expect(heredoc_wrap "<<A.size\nA").to eq "[{<<A.size}]\nA"
+      expect(heredoc_wrap "<<A.size 1\nA").to eq "[{<<A.size 1}]\nA"
+      expect(heredoc_wrap "<<A.size(1)\nA").to eq "[{<<A.size(1)}]\nA"
+      expect(heredoc_wrap "<<A.whatever <<B\nA\nB").to eq "[{<<A.whatever <<B}]\nA\nB"
+      expect(heredoc_wrap "<<A.whatever(<<B)\nA\nB").to eq "[{<<A.whatever(<<B)}]\nA\nB"
+      expect(heredoc_wrap "<<A.size()\nA").to eq "[{<<A.size()}]\nA"
     end
   end
 
@@ -760,36 +706,30 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     end
   end
 
-  # eventually, don't wrap these b/c they're spammy, but can be annoying since they can be accidentally wraped
-  # by e.g. a begin/end
-  # ignoring public/private/protected for now, b/c they're just methods, not keywords
   describe 'class definitions' do
     it 'does not wrap the class definition, does wrap the body' do
-      expect(wrap("class A\n1\nend")).to eq "class A\n<1>\nend"
+      expect(wrap("class A\n1\nend")).to eq "<class A\n<1>\nend>"
     end
 
     it 'does not wrap the superclass definition' do
-      expect(wrap("class A < B\nend")).to eq "class A < B\nend"
+      expect(wrap("class A < B\nend")).to eq "<class A < <B>\nend>"
     end
 
     it 'wraps the rescue body' do
-      expect(wrap("class A < B\n1\nrescue\n2\nend")).to eq "class A < B\n<1>\nrescue\n<2>\nend"
+      expect(wrap("class A < B\n1\nrescue\n2\nend")).to eq "<class A < <B>\n<1>\nrescue\n<2>\nend>"
     end
 
     it 'does not wrap the singleton class' do
-      expect(wrap("class << self\n end")).to eq "class << self\n end"
+      expect(wrap("class << self\n end")).to eq "<class << <self>\n end>"
     end
   end
 
-  # eventually, don't wrap these b/c they're spammy, but can be annoying since they can be accidentally wraped
-  # by e.g. a begin/end
-  # ignoring public/private/protected for now, b/c they're just methods, not keywords
   describe 'module definitions' do
     it 'does not wrap the definition, does wrap the body' do
-      expect(wrap("module A\n1\nend")).to eq "module A\n<1>\nend"
+      expect(wrap("module A\n1\nend")).to eq "<module A\n<1>\nend>"
     end
     it 'wraps the rescue portion' do
-      expect(wrap("module A\n1\nrescue\n2\nend")).to eq "module A\n<1>\nrescue\n<2>\nend"
+      expect(wrap("module A\n1\nrescue\n2\nend")).to eq "<module A\n<1>\nrescue\n<2>\nend>"
     end
   end
 
@@ -812,11 +752,15 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
 
     it 'wraps calls to yield' do
       expect(wrap("def a\nyield\nend")).to eq "<def a\n<yield>\nend>"
+      expect(wrap("def a\nyield 1\nend")).to eq "<def a\n<yield 1>\nend>"
+      expect(wrap("def a\nyield(\n1\n)\nend")).to eq "<def a\n<yield(\n<1>\n)>\nend>"
     end
 
     it 'wraps calls to super' do
       expect(wrap("def a\nsuper\nend")).to eq "<def a\n<super>\nend>"
       expect(wrap("def a\nsuper 1\nend")).to eq "<def a\n<super 1>\nend>"
+      expect(wrap("def a\nsuper(1)\nend")).to eq "<def a\n<super(1)>\nend>"
+      expect(wrap("def a\nsuper(\n1\n)\nend")).to eq "<def a\n<super(\n<1>\n)>\nend>"
     end
 
     it 'wraps the bodies of returns' do
@@ -828,11 +772,17 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("def a\n1\nrescue\n2\nensure\n3\nend")).to eq "<def a\n<1>\nrescue\n<2>\nensure\n<3>\nend>"
       expect(wrap("def a\n1\nensure\n2\nend")).to eq "<def a\n<1>\nensure\n<2>\nend>"
     end
+
+    it 'wrap a definition as a call to an invocation' do
+      expect(wrap("a def b\nc\nend,\nd")).to eq "<a <def b\n<c>\nend>,\nd>"
+    end
   end
 
   describe 'lambdas' do
     it 'wraps the lambda' do
       expect(wrap("lambda { }")).to eq "<lambda { }>"
+      expect(wrap("lambda { |;a| }")).to eq "<lambda { |;a| }>"
+      expect(wrap("lambda { |a,b=1,*c,&d| }")).to eq "<lambda { |a,b=1,*c,&d| }>"
       expect(wrap("-> { }")).to eq "<-> { }>"
       expect(wrap("-> a, b { }")).to eq "<-> a, b { }>"
       expect(wrap("-> {\n1\n}")).to eq "<-> {\n<1>\n}>"
@@ -865,15 +815,100 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
     #   <2>
     #   <3>]
     #
-    # idk, but then we also need to deal with the fact that we're changing result of __LINE__
-    # which we could do with some meta, just replacing it with the literal when we parse it
-    # but still, moving this out of here will be really annoying, and no one is going to use it, so fuck it
-    it 'does not record them', not_implemented: true do
-      pending 'not implemented, and probably never will be'
+    # Because not iw matters why you want to wrap it. Are you doing this because you want
+    # to catch an exception? then maybe your wrapping code needs to go around the inside of each begin block
+    # or maybe the begin blocks need to get consolidated into a single begin block.
+    # or maybe removed from the begin block and just stuck as normal fkn code at the top of the file?
+    # but we do need to rewrite __LINE__ expressions now, because they are changing.
+    # which... maybe that's fine.
+    #
+    # Or, you might just be interested in having your code execute first. In which case,
+    # it doesn't need to wrap the body, it just needs its own BEGIN block.
+    #
+    # note that there are also things line nested BEGINs and nested ENDs
+    # but you can't nest a BEGIN inside an END.
+    it 'does not record them' do
       expect(wrap("BEGIN {}")).to eq "BEGIN {}"
       expect(wrap("END {}")).to eq "END {}"
       expect(wrap("BEGIN {\n123\n}")).to eq "BEGIN {\n<123>\n}"
       expect(wrap("END {\n123\n}")).to eq "END {\n<123>\n}"
     end
+
+    it 'moves them out of the body', not_implemented: true do
+      expect(wrap_with_body(<<-HERE)).to eq(<<-THERE)
+        # encoding: utf-8
+        p [1, __LINE__]
+        BEGIN {
+          p [2, __LINE__]
+        }
+        p [3, __LINE__]
+        END {
+          p [4, __LINE__]
+        }
+        p [5, __LINE__]
+        BEGIN { p [6, __LINE__] }
+        END { p [7, __LINE__] }
+        p [8, __LINE__]
+      HERE
+        # encoding: utf-8
+        BEGIN {
+          <p [2, 4]>
+        }
+        BEGIN { <p [6, 11]> }
+        [<p [1, 2]>
+        <p [3, 6]>
+        <p [5, 10]>
+        <p [8, 13]>]
+        END {
+          <p [4, 8]>
+        }
+        END { <p [7, 12]> }
+      THERE
+    end
+  end
+
+  # only checking on 2.2 b/c its hard to figure out when different pieces were introduced
+  # we'll assume that if it passes on 2.2, it will pass on 2.0 or 2.1, if the feature is available on that Ruby
+  major, minor, * = RUBY_VERSION.split(".").map(&:to_i)
+  if major > 2 || (major == 2 && minor >= 2)
+    describe 'Ruby 2 syntaxes', :'2.x' => true do
+      it 'respects __dir__ macro' do
+        expect(wrap('__dir__')).to eq '<__dir__>'
+      end
+
+      it 'does not wrap keyword/keywordrest arguments' do
+        expect(wrap("def a(b,c=1,*d,e:,f:1,**g, &h)\n1\nend"))
+          .to eq "<def a(b,c=1,*d,e:,f:1,**g, &h)\n<1>\nend>"
+        expect(wrap("def a b:\n1\nend")).to eq "<def a b:\n<1>\nend>"
+        expect(wrap("def a b:\nreturn 1\nend")).to eq "<def a b:\nreturn <1>\nend>"
+        expect(wrap("def a b:\nreturn\nend")).to eq "<def a b:\nreturn\nend>"
+        expect(wrap("a b:1, **c")).to eq "<a b:1, **c>"
+        expect(wrap("{\na:1,\n**b\n}")).to eq "<{\na:<1>,\n**<b>\n}>"
+        expect(wrap("a(b:1,\n **c\n)")).to eq "<a(b:<1>,\n **<c>\n)>"
+        pending 'Fixed this in Parser, but it\'s not released yet https://github.com/whitequark/parser/commit/aeb95c776d11e212ed95b92c69e96d1cccdb6424'
+        expect(wrap("def a(*, **)\n1\nend")).to eq "<def a(*, **)\n<1>\nend>"
+      end
+
+      it 'tags javascript style hashes' do
+        expect(wrap(%[{\na:1,\n'b':2,\n"c":3\n}])).to eq %[<{\na:<1>,\n'b':<2>,\n"c":<3>\n}>]
+        expect(wrap(%[a b: 1,\n'c': 2,\n"d": 3,\n:e => 4])).to eq %[<a b: <1>,\n'c': <2>,\n"d": <3>,\n:e => 4>]
+      end
+
+      it 'wraps symbol literals' do
+        expect(wrap("%i[abc]")).to eq "<%i[abc]>"
+        expect(wrap("%I[abc]")).to eq "<%I[abc]>"
+        expect(wrap("%I[a\nb\nc]")).to eq "<%I[a\nb\nc]>"
+      end
+
+      it 'wraps complex and rational' do
+        expect(wrap("1i")).to eq "<1i>"
+        expect(wrap("5+1i")).to eq "<5+1i>"
+        expect(wrap("1r")).to eq "<1r>"
+        expect(wrap("1.5r")).to eq "<1.5r>"
+        expect(wrap("1/2r")).to eq "<1/2r>"
+        expect(wrap("2/1r")).to eq "<2/1r>"
+        expect(wrap("1ri")).to eq "<1ri>"
+      end
+    end
   end
 end