unparser 0.1.7 → 0.1.8

data/lib/unparser/emitter/undef.rb

@@ -7,8 +7,6 @@ module Unparser
 
       handle :undef
 
-      children :subject
-
     private
 
       # Perform dispatch
@@ -19,7 +17,7 @@ module Unparser
       #
       def dispatch
         write(K_UNDEF, WS)
-        visit(subject)
+        delimited(children)
       end
 
     end # Undef

data/lib/unparser/node_helpers.rb

@@ -11,7 +11,19 @@ module Unparser
     #
     # @api private
     #
-    def s(type, children = [])
+    def s(type, *children)
+      Parser::AST::Node.new(type, children)
+    end
+
+    # Helper for building nodes
+    #
+    # @param [Symbol]
+    #
+    # @return [Parser::AST::Node]
+    #
+    # @api private
+    #
+    def n(type, children = [])
       Parser::AST::Node.new(type, children)
     end
 

data/lib/unparser/preprocessor.rb

@@ -0,0 +1,226 @@
+# encoding: UTF-8
+
+module Unparser
+  # Preprocessor to normalize AST generated by parser
+  class Preprocessor
+    include Adamantium::Flat, NodeHelpers, AbstractType, Concord.new(:node), Procto.call(:result)
+
+    # Return preprocessor result
+    #
+    # @return [Parser::AST::Node]
+    #
+    # @api private
+    #
+    abstract_method :result
+
+    EMPTY = Parser::AST::Node.new(:empty)
+
+    # Run preprocessor for node
+    #
+    # @param [Parser::AST::Node, nil] node
+    #
+    # @return [Parser::AST::Node, nil]
+    #
+    # @api private
+    #
+    def self.run(node)
+      return EMPTY if node.nil?
+      REGISTRY.fetch(node.type, [Noop]).reduce(node) do |current, processor|
+        processor.call(current)
+      end
+    end
+
+    REGISTRY = Hash.new { |hash, key| hash[key] = [] }
+
+    # Register preprocessor
+    #
+    # @param [Symbol] type
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.register(type)
+      REGISTRY[type] << self
+    end
+    private_class_method :register
+
+  private
+
+    # Visit node
+    #
+    # @param [Parser::AST::Node]
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def visit(node)
+      self.class.run(node)
+    end
+
+    # Return children
+    #
+    # @return [Array<Parser::AST::Node>]
+    #
+    # @api private
+    #
+    def children
+      node.children
+    end
+
+    # Return visited children
+    #
+    # @return [Array<Parser::Ast::Node>]
+    #
+    # @api private
+    #
+    def visited_children
+      children.map do |node|
+        if node.kind_of?(Parser::AST::Node)
+          visit(node)
+        else
+          node
+        end
+      end
+    end
+
+    # Noop preprocessor that just passes through noode.
+    class Noop < self
+
+      register :int
+      register :str
+
+      # Return preprocessor result
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def result
+        node.updated(nil, visited_children)
+      end
+
+    end # Noop
+
+    # Preprocessor for dynamic string regexp and xtr nodes. Collapses adjacent string segments into one.
+    class CollapseStrChildren < self
+
+      register :dstr
+      register :regexp
+      register :xstr
+
+      # Return preprocessor result
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def result
+        node.updated(nil, collapsed_children)
+      end
+
+    private
+
+      # Return collapsed children
+      #
+      # @return [Array<Parser::AST::Node>]
+      #
+      # @api private
+      #
+      def collapsed_children
+        chunked_children.each_with_object([]) do |(type, nodes), aggregate|
+          if type == :str
+            aggregate << s(:str, nodes.map { |node| node.children.first }.join)
+          else
+            aggregate.concat(nodes)
+          end
+        end
+      end
+      memoize :collapsed_children
+
+      # Return chunked children
+      #
+      # @return [Array<Parser::AST::Node>]
+      #
+      # @api private
+      #
+      def chunked_children
+        visited_children.chunk(&:type)
+      end
+
+    end # CollapseStrChildren
+
+    # Preprocessor eliminating unneded dstr nodes
+    class CompactDSTR < self
+
+      register :dstr
+
+      # Return preprocessor result
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def result
+        if children.all? { |child| child.type == :str }
+          node.updated(:str, [children.map { |child| child.children.first }.join])
+        else
+          node
+        end
+      end
+
+    end # CompactDSTR
+
+    # Preprocessor transforming numeric nodes with infinity as value to round trippable aequivalent.
+    class Infinity < self
+
+      register :float
+      register :int
+
+      NEG_INFINITY = Float::INFINITY - 1
+
+      # Return preprocessor result
+      #
+      # @param [Parser::AST::Node]
+      #
+      # @api pirvate
+      #
+      def result
+        value = node.children.first
+        case value
+        when Float::INFINITY
+          s(:const, s(:const, nil, :Float), :INFINITY)
+        when -NEG_INFINITY
+          s(:send, s(:const, s(:const, nil, :Float), :INFINITY), :-@)
+        else
+          node
+        end
+      end
+    end
+
+    # Preprocessor for begin nodes. Removes begin nodes with one child.
+    #
+    # These superflownosely currently get generated by unparser.
+    #
+    class Begin < self
+
+      register :begin
+
+      # Return preprocessor result
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def result
+        if children.one?
+          visit(children.first)
+        else
+          Noop.call(node)
+        end
+      end
+
+    end # Begin
+  end # Preprocessor
+end # Unparser

data/lib/unparser/strip_helper.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Unparser
+  # Helpers for stripping source
+  module StripHelper
+
+    INDENT_PATTERN = /^\s*/.freeze
+
+    # String indentation of source away
+    #
+    # @param [String] source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def strip(source)
+      indent = source.rstrip.scan(INDENT_PATTERN).min_by(&:length)
+      source.gsub(/^#{indent}/, '')
+    end
+
+  end # StripHelper
+end # Unparser

data/rubyspec.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+exec bundle exec bin/unparser ../rubyspec --fail-fast             \
+  --ignore '../rubyspec/core/array/pack/{b,h,u}_spec.rb'          \
+  --ignore '../rubyspec/language/versions/*1.8*'                  \
+  --ignore '../rubyspec/core/array/pack/shared/float.rb'          \
+  --ignore '../rubyspec/core/array/pack/shared/integer.rb'        \
+  --ignore '../rubyspec/core/array/pack/{c,m,w}_spec.rb'          \
+  --ignore '../rubyspec/core/regexp/shared/new.rb'                \
+  --ignore '../rubyspec/core/regexp/shared/quote.rb'              \
+  --ignore '../rubyspec/core/encoding/compatible_spec.rb'         \
+  --ignore '../rubyspec/core/io/readpartial_spec.rb'              \
+  --ignore '../rubyspec/core/env/element_reference_spec.rb'       \
+  --ignore '../rubyspec/core/dir/pwd_spec.rb'                     \
+  --ignore '../rubyspec/core/string/casecmp_spec.rb'              \
+  --ignore '../rubyspec/core/string/unpack/{b,c,h,m,u,w}_spec.rb' \
+  --ignore '../rubyspec/core/string/unpack/b_spec.rb'             \
+  --ignore '../rubyspec/core/string/unpack/shared/float.rb'       \
+  --ignore '../rubyspec/core/string/unpack/shared/integer.rb'     \
+  --ignore '../rubyspec/core/symbol/casecmp_spec.rb'              \
+  $*

data/spec/spec_helper.rb

@@ -20,6 +20,8 @@ module SpecHelper
 end
 
 RSpec.configure do |config|
+  config.extend(Unparser::StripHelper)
+  config.include(Unparser::StripHelper)
   config.include(SpecHelper)
   config.extend(SpecHelper)
 end

data/spec/unit/unparser_spec.rb

@@ -29,6 +29,8 @@ describe Unparser do
       ast, comments = parser.parse_with_comments(input)
       generated = Unparser.unparse(ast, comments)
       generated.should eql(input)
+      generated_ast, _ = parser.parse_with_comments(generated)
+      expect(ast == generated_ast).to be(true)
     end
 
     def assert_generates_from_string(parser, string, expected)
@@ -74,14 +76,17 @@ describe Unparser do
         assert_generates s(:int,  1),  '1'
         assert_generates s(:int, -1), '-1'
         assert_source '1'
+        assert_source '++1'
         assert_generates '0x1', '1'
         assert_generates '1_000', '1000'
         assert_generates '1e10',  '10000000000.0'
+        assert_generates '10e10000000000', 'Float::INFINITY'
+        assert_generates '-10e10000000000', '-Float::INFINITY'
       end
 
       context 'string' do
         assert_generates '?c', '"c"'
-        assert_source %q("foo" "bar")
+        assert_generates %q("foo" "bar"), %q("foobar")
         assert_generates %q(%Q(foo"#{@bar})), %q("foo\\"#{@bar}")
         assert_source %q("\"")
         assert_source %q("foo#{1}bar")
@@ -125,6 +130,7 @@ describe Unparser do
         assert_source ':foo'
         assert_source ':"A B"'
         assert_source ':"A\"B"'
+        assert_source ':""'
       end
 
       context 'regexp' do
@@ -169,12 +175,16 @@ describe Unparser do
       context 'float' do
         assert_source '-0.1'
         assert_source '0.1'
+        assert_source '0.1'
+        assert_generates '10.2e10000000000', 'Float::INFINITY'
+        assert_generates '-10.2e10000000000', '-Float::INFINITY'
         assert_generates s(:float, -0.1), '-0.1'
         assert_generates s(:float, 0.1), '0.1'
       end
 
       context 'array' do
         assert_source '[1, 2]'
+        assert_source '[1, (), n2]'
         assert_source '[1]'
         assert_source '[]'
         assert_source '[1, *@foo]'
@@ -185,10 +195,12 @@ describe Unparser do
 
       context 'hash' do
         assert_source '{}'
+        assert_source '{ () => () }'
         assert_source '{ 1 => 2 }'
         assert_source '{ 1 => 2, 3 => 4 }'
 
         context 'with symbol keys' do
+          assert_source '{ a: (1 rescue(foo)), b: 2 }'
           assert_source '{ a: 1, b: 2 }'
           assert_source '{ a: :a }'
           assert_source '{ :"a b" => 1 }'
@@ -209,11 +221,6 @@ describe Unparser do
       assert_source '::TOPLEVEL::CONST'
     end
 
-    context 'next' do
-      assert_source 'next'
-      assert_source 'next(bar)'
-    end
-
     context 'retry' do
       assert_source 'retry'
     end
@@ -231,8 +238,8 @@ describe Unparser do
 
     context 'magic keywords' do
       assert_generates '__ENCODING__', 'Encoding::UTF_8'
-      assert_source '__FILE__'
-      assert_source '__LINE__'
+      assert_generates '__FILE__', '"(string)"'
+      assert_generates '__LINE__', '1'
     end
 
     context 'assignment' do
@@ -246,51 +253,122 @@ describe Unparser do
         assert_source '::Foo = ::Bar'
       end
 
+      context 'lvar assigned from method with same name' do
+        assert_source 'foo = foo()'
+      end
+
+      context 'lvar introduction from condition' do
+        assert_source 'foo = bar while foo'
+        assert_source 'foo = bar until foo'
+        assert_source <<-'RUBY'
+          foo = exp
+          while foo
+            foo = bar
+          end
+        RUBY
+
+        # Ugly I know. But its correct :D
+        #
+        # if foo { |pair| }
+        #   pair = :foo
+        #   foo
+        # end
+        assert_source <<-'RUBY'
+          if foo do |pair|
+            pair
+          end
+            pair = :foo
+            foo
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          while foo
+            foo = bar
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          each do |bar|
+            while foo
+              foo = bar
+            end
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def foo
+            foo = bar while foo != baz
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          each do |baz|
+            while foo
+              foo = bar
+            end
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          each do |foo|
+            while foo
+              foo = bar
+            end
+          end
+        RUBY
+      end
+
       context 'multiple' do
-        assert_source 'a, b = 1, 2'
-        assert_source 'a, *foo = 1, 2'
-        assert_source 'a, * = 1, 2'
-        assert_source '*foo = 1, 2'
-        assert_source '@a, @b = 1, 2'
-        assert_source 'a.foo, a.bar = 1, 2'
+        assert_source 'a, b = [1, 2]'
+        assert_source 'a, *foo = [1, 2]'
+        assert_source 'a, * = [1, 2]'
+        assert_source '*foo = [1, 2]'
+        assert_source '*a = []'
+        assert_source '@a, @b = [1, 2]'
+        assert_source 'a.foo, a.bar = [1, 2]'
         assert_source 'a[0, 2]'
-        assert_source 'a[0], a[1] = 1, 2'
-        assert_source 'a[*foo], a[1] = 1, 2'
-        assert_source '@@a, @@b = 1, 2'
-        assert_source '$a, $b = 1, 2'
+        assert_source 'a[0], a[1] = [1, 2]'
+        assert_source 'a[*foo], a[1] = [1, 2]'
+        assert_source '@@a, @@b = [1, 2]'
+        assert_source '$a, $b = [1, 2]'
         assert_source 'a, b = foo'
-        assert_source 'a, (b, c) = 1, [2, 3]'
+        assert_source 'a, (b, c) = [1, [2, 3]]'
+        assert_source 'a, = foo'
       end
     end
 
-    context 'return' do
-      assert_source <<-'RUBY'
-        return
-      RUBY
-
-      assert_source <<-'RUBY'
-        return(1)
-      RUBY
+    %w(next return break).each do |keyword|
 
-      assert_source <<-'RUBY'
-        return(1), (2)
-      RUBY
+      context keyword do
+        assert_source "#{keyword}"
+        assert_source "#{keyword} 1"
+        assert_source "#{keyword} 2, 3"
+        assert_source "#{keyword} *nil"
+        assert_source "#{keyword} *foo, bar"
 
-      assert_generates <<-'RUBY', <<-'RUBY'
-        return(a ? b : c)
-      RUBY
-        return(if a
-          b
-        else
-          c
-        end)
-      RUBY
-    end
+        assert_generates <<-RUBY, <<-RUBY
+          foo do |bar|
+            bar =~ // || #{keyword}
+            baz
+          end
+        RUBY
+          foo do |bar|
+            (bar =~ //) || #{keyword}
+            baz
+          end
+        RUBY
 
-    context 'break' do
-      assert_source 'break'
-      assert_source 'break(a)'
-      assert_source 'break(a), (b)'
+        assert_generates <<-RUBY, <<-RUBY
+          #{keyword}(a ? b : c)
+        RUBY
+          #{keyword} (if a
+            b
+          else
+            c
+          end)
+        RUBY
+      end
     end
 
     context 'send' do
@@ -303,6 +381,7 @@ describe Unparser do
       assert_source 'foo(1)'
       assert_source 'foo(bar)'
       assert_source 'foo(&block)'
+      assert_source 'foo(&(foo || bar))'
       assert_source 'foo(*arguments)'
       assert_source 'foo(*arguments)'
       assert_source <<-'RUBY'
@@ -350,6 +429,33 @@ describe Unparser do
         end
       RUBY
 
+      assert_source <<-'RUBY'
+        foo.bar do |*a; b|
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        foo.bar do |a; b|
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        foo.bar do |; a, b|
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        foo.bar do |((*))|
+          d
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        foo.bar do |(a, (*))|
+          d
+        end
+      RUBY
+
       assert_source <<-'RUBY'
         foo.bar do |(a, b)|
           d
@@ -405,6 +511,14 @@ describe Unparser do
         end.bar
       RUBY
 
+      assert_source <<-'RUBY'
+        case (def foo
+        end
+        :bar)
+        when bar
+        end.baz
+      RUBY
+
       assert_source <<-'RUBY'
         case foo
         when bar
@@ -476,8 +590,8 @@ describe Unparser do
 
       assert_source 'foo.bar(&baz)'
       assert_source 'foo.bar(:baz, &baz)'
-      assert_source 'foo.bar=(:baz)'
-      assert_source 'self.foo=(:bar)'
+      assert_source 'foo.bar=:baz'
+      assert_source 'self.foo=:bar'
 
       assert_source 'foo.bar(baz: boz)'
       assert_source 'foo.bar(foo, "baz" => boz)'
@@ -488,6 +602,11 @@ describe Unparser do
     context 'begin; end' do
       assert_generates s(:begin), ''
 
+      assert_source <<-'RUBY'
+        begin
+        end
+      RUBY
+
       assert_source <<-'RUBY'
         foo
         bar
@@ -532,6 +651,13 @@ describe Unparser do
         end
       RUBY
 
+      assert_source <<-'RUBY'
+        begin
+          raise(Exception) rescue(foo = bar)
+        rescue Exception
+        end
+      RUBY
+
       assert_source <<-'RUBY'
         begin
           foo
@@ -566,6 +692,24 @@ describe Unparser do
         end
       RUBY
 
+      assert_source <<-'RUBY'
+        class << self
+          undef :bar rescue(nil)
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        module Foo
+          undef :bar rescue(nil)
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        class Foo
+          undef :bar rescue(nil)
+        end
+      RUBY
+
       assert_source <<-'RUBY'
         begin
         rescue Exception => e
@@ -636,36 +780,42 @@ describe Unparser do
       RUBY
 
       assert_source 'foo rescue(bar)'
-      assert_source 'foo rescue(return(bar))'
-      assert_source 'x = foo rescue(return(bar))'
+      assert_source 'foo rescue(return bar)'
+      assert_source 'x = foo rescue(return bar)'
     end
 
     context 'super' do
       assert_source 'super'
 
+      assert_source 'super()'
+      assert_source 'super(a)'
+      assert_source 'super(a, b)'
+      assert_source 'super(&block)'
+      assert_source 'super(a, &block)'
+
       assert_source <<-'RUBY'
-        super do
+        super(a do
           foo
-        end
+        end)
       RUBY
 
-      assert_source 'super()'
-
       assert_source <<-'RUBY'
-        super() do
+        super do
           foo
         end
       RUBY
 
-      assert_source 'super(a)'
-
       assert_source <<-'RUBY'
         super(a) do
           foo
         end
       RUBY
 
-      assert_source 'super(a, b)'
+      assert_source <<-'RUBY'
+        super() do
+          foo
+        end
+      RUBY
 
       assert_source <<-'RUBY'
         super(a, b) do
@@ -673,12 +823,11 @@ describe Unparser do
         end
       RUBY
 
-      assert_source 'super(&block)'
-      assert_source 'super(a, &block)'
     end
 
     context 'undef' do
       assert_source 'undef :foo'
+      assert_source 'undef :foo, :bar'
     end
 
     context 'BEGIN' do
@@ -758,6 +907,30 @@ describe Unparser do
         if foo
         end
       RUBY
+
+      assert_source <<-'RUBY'
+        foo = bar if foo
+      RUBY
+
+      assert_source <<-'RUBY'
+        foo = bar unless foo
+      RUBY
+
+      assert_source <<-'RUBY'
+        def foo(*foo)
+          unless foo
+            foo = bar
+          end
+        end
+      RUBY
+
+      assert_source <<-'RUBY'
+        each do |foo|
+          unless foo
+            foo = bar
+          end
+        end
+      RUBY
     end
 
     context 'def' do
@@ -784,6 +957,14 @@ describe Unparser do
           end
         RUBY
 
+        assert_source <<-'RUBY'
+          begin
+            foo
+          ensure
+            bar rescue(nil)
+          end
+        RUBY
+
         assert_source <<-'RUBY'
           def foo
             bar
@@ -820,6 +1001,18 @@ describe Unparser do
           end
         RUBY
 
+        assert_source <<-'RUBY'
+          def foo(bar = ())
+            bar
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def foo(bar = (baz
+          nil))
+          end
+        RUBY
+
         assert_source <<-'RUBY'
           def foo(bar = true)
             bar
@@ -902,6 +1095,43 @@ describe Unparser do
             baz
           end
         RUBY
+
+        assert_source <<-'RUBY'
+          def (foo do |bar|
+          end).bar
+            bar
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def (foo(1)).bar
+            bar
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def (Foo::Bar.baz).bar
+            baz
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def (Foo::Bar).bar
+            baz
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def Foo.bar
+            baz
+          end
+        RUBY
+
+        assert_source <<-'RUBY'
+          def foo.bar
+            baz
+          end
+        RUBY
       end
 
       context 'on singleton' do
@@ -934,7 +1164,7 @@ describe Unparser do
       context 'class' do
         assert_source <<-'RUBY'
           class TestClass
-          end # TestClass
+          end
         RUBY
 
         assert_source <<-'RUBY'
@@ -950,22 +1180,22 @@ describe Unparser do
 
         assert_source <<-'RUBY'
           class SomeNameSpace::TestClass
-          end # SomeNameSpace::TestClass
+          end
         RUBY
 
         assert_source <<-'RUBY'
           class Some::Name::Space::TestClass
-          end # Some::Name::Space::TestClass
+          end
         RUBY
 
         assert_source <<-'RUBY'
           class TestClass < Object
-          end # TestClass
+          end
         RUBY
 
         assert_source <<-'RUBY'
           class TestClass < SomeNameSpace::Object
-          end # TestClass
+          end
         RUBY
 
         assert_source <<-'RUBY'
@@ -973,12 +1203,12 @@ describe Unparser do
             def foo
               :bar
             end
-          end # TestClass
+          end
         RUBY
 
         assert_source <<-'RUBY'
           class ::TestClass
-          end # ::TestClass
+          end
         RUBY
       end
 
@@ -986,17 +1216,17 @@ describe Unparser do
 
         assert_source <<-'RUBY'
           module TestModule
-          end # TestModule
+          end
         RUBY
 
         assert_source <<-'RUBY'
           module SomeNameSpace::TestModule
-          end # SomeNameSpace::TestModule
+          end
         RUBY
 
         assert_source <<-'RUBY'
           module Some::Name::Space::TestModule
-          end # Some::Name::Space::TestModule
+          end
         RUBY
 
         assert_source <<-'RUBY'
@@ -1004,7 +1234,7 @@ describe Unparser do
             def foo
               :bar
             end
-          end # TestModule
+          end
         RUBY
 
       end
@@ -1019,6 +1249,8 @@ describe Unparser do
       context 'element assignment' do
         assert_source 'array[index] = value'
         assert_source 'array[*index] = value'
+        assert_source 'array[a, b] = value'
+        assert_source 'array.[]=()'
 
         %w(+ - * / % & | || &&).each do |operator|
           context "with #{operator}" do
@@ -1036,6 +1268,10 @@ describe Unparser do
         assert_source <<-'RUBY'
           defined?(Foo)
         RUBY
+
+        assert_source <<-'RUBY'
+          defined?((a, b = [1, 2]))
+        RUBY
       end
     end
 
@@ -1064,7 +1300,8 @@ describe Unparser do
 
     context 'binary operator methods' do
       %w(+ - * / & | << >> == === != <= < <=> > >= =~ !~ ^ **).each do |operator|
-        assert_source "1 #{operator} 2"
+        assert_source "(-1) #{operator} 2"
+        assert_source "(-1.2) #{operator} 2"
         assert_source "left.#{operator}(*foo)"
         assert_source "left.#{operator}(a, b)"
         assert_source "self #{operator} b"
@@ -1082,15 +1319,18 @@ describe Unparser do
     end
 
     context 'binary operator' do
-      assert_source 'a || (break(foo))'
-      assert_source '(break(foo)) || a'
+      assert_source 'a || (return foo)'
+      assert_source '(return foo) || a'
+      assert_source 'a || (break foo)'
+      assert_source '(break foo) || a'
       assert_source '(a || b).foo'
       assert_source 'a || (b || c)'
     end
 
     { or: :'||', and: :'&&' }.each do |word, symbol|
-      assert_generates "a #{word} break foo", "a #{symbol} (break(foo))"
-      assert_generates "a #{word} next foo", "a #{symbol} (next(foo))"
+      assert_generates "a #{word} return foo", "a #{symbol} (return foo)"
+      assert_generates "a #{word} break foo", "a #{symbol} (break foo)"
+      assert_generates "a #{word} next foo", "a #{symbol} (next foo)"
     end
 
     context 'expansion of shortcuts' do
@@ -1199,12 +1439,13 @@ describe Unparser do
 
     context 'unary operators' do
       assert_source '!1'
-      assert_source '!!1'
-      assert_source '!!(foo || bar)'
+      assert_source '!(!1)'
+      assert_source '!(!(foo || bar))'
       assert_source '!(!1).baz'
       assert_source '~a'
       assert_source '-a'
       assert_source '+a'
+      assert_source '-(-a).foo'
     end
 
     context 'loop' do
@@ -1263,84 +1504,82 @@ describe Unparser do
       RUBY
     end
 
-    context 'comments' do
-      assert_source <<-'RUBY'
-        # comment before
-        a_line_of_code
-      RUBY
-
-      assert_source <<-'RUBY'
-        a_line_of_code # comment after
-      RUBY
-
-      assert_source <<-'RUBY'
-        nested do # first
-          # second
-          something # comment
-          # another
-        end
-        # last
-      RUBY
-
-      assert_generates <<-'RUBY', <<-'RUBY'
-        foo if bar
-        # comment
-      RUBY
-        if bar
-          foo
-        end
-        # comment
-      RUBY
+    assert_source <<-'RUBY'
+      # comment before
+      a_line_of_code
+    RUBY
 
-      assert_source <<-'RUBY'
-        def noop
-          # do nothing
-        end
-      RUBY
+    assert_source <<-'RUBY'
+      a_line_of_code # comment after
+    RUBY
 
-      assert_source <<-'RUBY'
-        =begin
-          block comment
-        =end
-        nested do
-        =begin
-        another block comment
-        =end
-          something
-        =begin
-        last block comment
-        =end
-        end
-      RUBY
-
-      assert_generates(<<-'RUBY', <<-'RUBY')
-        1 + # first
-          2 # second
-      RUBY
-        1 + 2 # first # second
-      RUBY
-
-      assert_generates(<<-'RUBY', <<-'RUBY')
-        1 +
-          # first
-          2 # second
-      RUBY
-        1 + 2 # first # second
-      RUBY
+    assert_source <<-'RUBY'
+      nested do # first
+        # second
+        something # comment
+        # another
+      end
+      # last
+    RUBY
+
+    assert_generates <<-'RUBY', <<-'RUBY'
+      foo if bar
+      # comment
+    RUBY
+      if bar
+        foo
+      end
+      # comment
+    RUBY
 
-      assert_generates(<<-'RUBY', <<-'RUBY')
-        1 +
-        =begin
-          block comment
-        =end
-          2
-      RUBY
-        1 + 2
-        =begin
-          block comment
-        =end
-      RUBY
+    assert_source <<-'RUBY'
+      def noop
+        # do nothing
+      end
+    RUBY
+
+    assert_source <<-'RUBY'
+      =begin
+        block comment
+      =end
+      nested do
+      =begin
+      another block comment
+      =end
+        something
+      =begin
+      last block comment
+      =end
+      end
+    RUBY
+
+    assert_generates(<<-'RUBY', <<-'RUBY')
+      1 + # first
+        2 # second
+    RUBY
+      1 + 2 # first # second
+    RUBY
+
+    assert_generates(<<-'RUBY', <<-'RUBY')
+      1 +
+        # first
+        2 # second
+    RUBY
+      1 + 2 # first # second
+    RUBY
+
+    assert_generates(<<-'RUBY', <<-'RUBY')
+      1 +
+      =begin
+        block comment
+      =end
+        2
+    RUBY
+      1 + 2
+      =begin
+        block comment
+      =end
+    RUBY
 
-    end
   end
 end