unparser 0.0.16 → 0.0.18

data/unparser.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name     = 'unparser'
-  s.version  = '0.0.16'
+  s.version  = '0.0.18'
 
   s.authors  = ['Markus Schirp']
   s.email    = 'mbj@schir-dso.com'
@@ -18,8 +18,8 @@ Gem::Specification.new do |s|
   s.executables      = [ 'test-unparser' ]
 
   s.add_dependency('parser',        '~> 2.0.0.pre6')
-  s.add_dependency('concord',       '~> 0.1.1')
-  s.add_dependency('adamantium',    '~> 0.0.10')
-  s.add_dependency('equalizer',     '~> 0.0.5')
-  s.add_dependency('abstract_type', '~> 0.0.5')
+  s.add_dependency('concord',       '~> 0.1.1'     )
+  s.add_dependency('adamantium',    '~> 0.1.0'     )
+  s.add_dependency('equalizer',     '~> 0.0.7'     )
+  s.add_dependency('abstract_type', '~> 0.0.6'     )
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unparser
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - Markus Schirp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-21 00:00:00.000000000 Z
+date: 2013-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -44,42 +44,42 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.10
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.10
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: equalizer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.7
 - !ruby/object:Gem::Dependency
   name: abstract_type
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.6
 description: Generate equivalent source for parser gem AST nodes
 email: mbj@schir-dso.com
 executables:
@@ -160,7 +160,6 @@ files:
 - lib/unparser/emitter/variable.rb
 - lib/unparser/emitter/yield.rb
 - lib/unparser/finalize.rb
-- spec/integration/unparser/spike_spec.rb
 - spec/spec_helper.rb
 - spec/unit/unparser/buffer/append_spec.rb
 - spec/unit/unparser/buffer/content_spec.rb
@@ -171,6 +170,7 @@ files:
 - spec/unit/unparser/emitter/class_methods/handle_spec.rb
 - spec/unit/unparser/emitter/class_methods/visit_spec.rb
 - spec/unit/unparser/emitter/source_map/class_methods/emit_spec.rb
+- spec/unit/unparser_spec.rb
 - unparser.gemspec
 homepage: http://github.com/mbj/unparser
 licenses:
@@ -197,7 +197,6 @@ signing_key:
 specification_version: 4
 summary: Generate equivalent source for parser gem AST nodes
 test_files:
-- spec/integration/unparser/spike_spec.rb
 - spec/spec_helper.rb
 - spec/unit/unparser/buffer/append_spec.rb
 - spec/unit/unparser/buffer/content_spec.rb
@@ -208,4 +207,5 @@ test_files:
 - spec/unit/unparser/emitter/class_methods/handle_spec.rb
 - spec/unit/unparser/emitter/class_methods/visit_spec.rb
 - spec/unit/unparser/emitter/source_map/class_methods/emit_spec.rb
+- spec/unit/unparser_spec.rb
 has_rdoc: 

data/spec/integration/unparser/spike_spec.rb

@@ -1,1091 +0,0 @@
-require 'spec_helper'
-
-describe Unparser, 'spike' do
-
-
-  PARSERS = IceNine.deep_freeze(
-    '1.8' => Parser::Ruby18,
-    '1.9' => Parser::Ruby19,
-    '2.0' => Parser::Ruby20,
-    '2.1' => Parser::Ruby21
-  )
-
-  RUBIES = PARSERS.keys.freeze
-
-  def self.parser_for_ruby_version(version)
-    PARSERS.fetch(version) do
-      raise "Unrecognized Ruby version #{version}"
-    end
-  end
-
-  def self.with_versions(versions)
-    versions.each do |version|
-      parser = parser_for_ruby_version(version)
-      yield version, parser
-    end
-  end
-
-  def self.strip(ruby)
-    lines = ruby.lines
-    line = lines.first
-    match = /\A[ ]*/.match(line)
-    length = match[0].length
-    source = lines.map do |line|
-      line[(length..-1)]
-    end.join
-    source.chomp
-  end
-
-  def assert_round_trip(input, parser)
-    ast = parser.parse(input)
-    generated = Unparser.unparse(ast)
-    generated.should eql(input)
-  end
-
-  def self.assert_generates_one_way(ast, expected, versions = RUBIES)
-    with_versions(versions) do |version, parser|
-      it "should generate #{ast.inspect} as #{expected} under #{version}" do
-        if ast.kind_of?(String)
-          ast = parser.parse(ast)
-        end
-        generated = Unparser.unparse(ast)
-        generated.should eql(expected)
-      end
-    end
-  end
-
-  def self.assert_generates(ast, expected, versions = RUBIES)
-    with_versions(versions) do |version, parser|
-      it "should generate #{ast.inspect} as #{expected} under #{version}" do
-        if ast.kind_of?(String)
-          ast = parser.parse(ast)
-        end
-        generated = Unparser.unparse(ast)
-        generated.should eql(expected)
-        ast = parser.parse(generated)
-        Unparser.unparse(ast).should eql(expected)
-      end
-    end
-  end
-
-  def self.assert_round_trip(input, versions = RUBIES)
-    with_versions(versions) do |version, parser|
-      it "should round trip #{input.inspect} under #{version}" do
-        assert_round_trip(input, parser)
-      end
-    end
-  end
-
-  def self.assert_source(input, versions = RUBIES)
-    assert_round_trip(strip(input), versions)
-  end
-
-  context 'literal' do
-    context 'fixnum' do
-      assert_generates s(:int,  1),  '1'
-      assert_generates s(:int, -1), '-1'
-      assert_source '1'
-      assert_generates '0x1', '1'
-      assert_generates '1_000', '1000'
-      assert_generates '1e10',  '10000000000.0'
-      assert_generates '?c', '"c"', RUBIES  - %w(1.8)
-      assert_generates '?c', '99', %w(1.8)
-    end
-
-    context 'string' do
-      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")
-      assert_source %q("\"#{@a}")
-    end
-
-    context 'execute string' do
-      assert_source '`foo`'
-      assert_source '`foo#{@bar}`'
-      assert_generates  '%x(\))', '`)`'
-     #assert_generates  '%x(`)', '`\``'
-      assert_source '`"`'
-    end
-
-    context 'symbol' do
-      assert_generates s(:sym, :foo), ':foo'
-      assert_generates s(:sym, :"A B"), ':"A B"'
-      assert_source ':foo'
-      assert_source ':"A B"'
-      assert_source ':"A\"B"'
-    end
-
-    context 'regexp' do
-      assert_source '/foo/'
-      assert_source %q(/[^-+',.\/:@[:alnum:]\[\]\x80-\xff]+/)
-      assert_source '/foo#{@bar}/'
-      assert_source '/foo#{@bar}/imx'
-      assert_source "/\n/"
-      assert_source '/\n/'
-      assert_source "/\n/x"
-      assert_generates '%r(/)', '/\//'
-      assert_generates '%r(\))', '/)/'
-      assert_generates '%r(#{@bar}baz)', '/#{@bar}baz/'
-    end
-
-    context 'dynamic string' do
-      assert_source %q("foo#{@bar}")
-      assert_source     %q("fo\no#{bar}b\naz")
-    end
-
-    context 'dynamic symbol' do
-      assert_source ':"foo#{bar}baz"'
-      assert_source ':"fo\no#{bar}b\naz"'
-      assert_source ':"#{bar}foo"'
-      assert_source ':"foo#{bar}"'
-    end
-
-    context 'irange' do
-      assert_generates '1..2', %q(1..2)
-      assert_source   '(0.0 / 0.0)..1'
-      assert_source   '1..(0.0 / 0.0)'
-    end
-
-    context 'erange' do
-      assert_generates '1...2', %q(1...2)
-    end
-
-    context 'float' do
-      assert_source '-0.1'
-      assert_source '0.1'
-      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]'
-      assert_source '[]'
-      assert_source '[1, *@foo]'
-      assert_source '[*@foo, 1]',     RUBIES - %w(1.8)
-      assert_source '[*@foo, *@baz]', RUBIES - %w(1.8)
-      assert_generates '%w(foo bar)', %q(["foo", "bar"])
-    end
-
-    context 'hash' do
-      assert_source '{}'
-      assert_source '{1 => 2}'
-      assert_source '{1 => 2, 3 => 4}'
-    end
-  end
-
-  context 'access' do
-    assert_source '@a'
-    assert_source '@@a'
-    assert_source '$a'
-    assert_source '$1'
-    assert_source '$`'
-    assert_source 'CONST'
-    assert_source 'SCOPED::CONST'
-    assert_source '::TOPLEVEL'
-    assert_source '::TOPLEVEL::CONST'
-  end
-
-  context 'break' do
-    assert_source 'break'
-    assert_source 'break(a)'
-  end
-
-  context 'next' do
-    assert_source 'next'
-    assert_source 'next(bar)'
-  end
-
-  context 'retry' do
-    assert_source 'retry'
-  end
-
-  context 'redo' do
-    assert_source 'redo'
-  end
-
-  context 'singletons' do
-    assert_source 'self'
-    assert_source 'true'
-    assert_source 'false'
-    assert_source 'nil'
-  end
-
-  context 'magic keywords' do
-    assert_generates '__ENCODING__', 'Encoding::UTF_8', RUBIES - %w(1.8)
-    assert_source '__FILE__'
-    assert_source '__LINE__'
-  end
-
-  context 'assignment' do
-    context 'single' do
-      assert_source 'a = 1'
-      assert_source '@a = 1'
-      assert_source '@@a = 1'
-      assert_source '$a = 1'
-      assert_source 'CONST = 1'
-    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[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, b = foo'
-      assert_source 'a, (b, c) = 1, [2, 3]'
-      assert_generates_one_way s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)), 'a, b'
-    end
-  end
-
-  context 'return' do
-    assert_source <<-RUBY
-      return
-    RUBY
-
-    assert_source <<-RUBY
-      return(1)
-    RUBY
-  end
-
-  context 'send' do
-    assert_source 'foo'
-    assert_source 'self.foo'
-    assert_source 'a.foo'
-    assert_source 'A.foo'
-    assert_source 'foo[1]'
-    assert_source 'foo[*baz]'
-    assert_source 'foo(1)'
-    assert_source 'foo(bar)'
-    assert_source 'foo(&block)'
-    assert_source 'foo(*arguments)'
-    assert_source 'foo(*arguments)'
-    assert_source <<-RUBY
-      foo do
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo(1) do
-        nil
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo do |a, b|
-        nil
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo do |a, *b|
-        nil
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo do |a, *|
-        nil
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo do
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo.bar(*args)
-    RUBY
-
-    assert_source <<-RUBY
-      foo.bar do |(a, b), c|
-        d
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      foo.bar do |(a, b)|
-        d
-      end
-    RUBY
-
-    # Special cases
-    assert_source '(1..2).max'
-
-    assert_source 'foo.bar(*args)'
-    assert_source 'foo.bar(*arga, foo, *argb)', RUBIES - %w(1.8)
-    assert_source 'foo.bar(*args, foo)',        RUBIES - %w(1.8)
-    assert_source 'foo.bar(foo, *args)'
-    assert_source 'foo.bar(foo, *args, &block)'
-    assert_source <<-RUBY
-      foo(bar, *args)
-    RUBY
-
-    assert_source <<-RUBY
-      foo(*args, &block)
-    RUBY
-
-    assert_source 'foo.bar(&baz)'
-    assert_source 'foo.bar(:baz, &baz)'
-    assert_source 'foo.bar=(:baz)'
-    assert_source 'self.foo=(:bar)'
-  end
-
-  context 'begin; end' do
-    assert_generates s(:begin), ''
-
-    assert_source <<-RUBY
-      foo
-      bar
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-        bar
-      end.blah
-    RUBY
-  end
-
-  context 'begin / rescue / ensure' do
-    assert_source <<-RUBY
-      begin
-        foo
-      ensure
-        bar
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-      rescue
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        begin
-          foo
-          bar
-        rescue
-        end
-      rescue
-        baz
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-        bar
-      rescue
-        baz
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-      rescue Exception
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-      rescue => bar
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-      rescue Exception, Other => bar
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-      rescue Exception => e
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-      rescue
-      ensure
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-      rescue Exception => bar
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        bar
-      rescue SomeError, *bar
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        bar
-      rescue SomeError, *bar => exception
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        bar
-      rescue *bar
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        bar
-      rescue LoadError
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        bar
-      rescue
-      else
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        bar
-      rescue *bar => exception
-        baz
-      end
-    RUBY
-  end
-
-  context 'super' do
-    assert_source 'super'
-
-    assert_source <<-RUBY
-      super do
-        foo
-      end
-    RUBY
-
-    assert_source 'super()'
-
-    assert_source <<-RUBY
-      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(a, b) do
-        foo
-      end
-    RUBY
-
-    assert_source 'super(&block)'
-    assert_source 'super(a, &block)'
-  end
-
-  context 'undef' do
-    assert_source 'undef :foo'
-  end
-
-  context 'BEGIN' do
-    assert_source <<-RUBY
-      BEGIN {
-        foo
-      }
-    RUBY
-  end
-
-  context 'END' do
-    assert_source <<-RUBY
-      END {
-        foo
-      }
-    RUBY
-  end
-
-  context 'alias' do
-    assert_source <<-RUBY
-      alias $foo $bar
-    RUBY
-
-    assert_source <<-RUBY
-      alias :foo :bar
-    RUBY
-  end
-
-  context 'yield' do
-    context 'without arguments' do
-      assert_source 'yield'
-    end
-
-    context 'with argument' do
-      assert_source 'yield(a)'
-    end
-
-    context 'with arguments' do
-      assert_source 'yield(a, b)'
-    end
-  end
-
-  context 'if statement' do
-    assert_source <<-RUBY
-      if /foo/
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      if 3
-        9
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      if 4
-        5
-      else
-        6
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      unless 3
-        nil
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      unless 3
-        9
-      end
-    RUBY
-  end
-
-  context 'def' do
-    context 'on instance' do
-
-      assert_source <<-RUBY
-        def foo
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo
-          bar
-        ensure
-          baz
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo
-          bar
-        rescue
-          baz
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar, baz)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar = true)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar, baz = true)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY, %w(1.9 2.0)
-        def foo(bar, baz = true, foo)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY, %w(2.1)
-        def foo(bar: 1)
-        end
-      RUBY
-
-      assert_source <<-RUBY, %w(2.0)
-        def foo(**bar)
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(*)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(*bar)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar, *baz)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(baz = true, *bor)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(baz = true, *bor, &block)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar, baz = true, *bor)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(&block)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo(bar, &block)
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def foo
-          bar
-          baz
-        end
-      RUBY
-    end
-
-    context 'on singleton' do
-      assert_source <<-RUBY
-        def self.foo
-        end
-      RUBY
-
-
-      assert_source <<-RUBY
-        def self.foo
-          bar
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def self.foo
-          bar
-          baz
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        def Foo.bar
-          bar
-        end
-      RUBY
-
-    end
-
-    context 'class' do
-      assert_source <<-RUBY
-        class TestClass
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class << some_object
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class << some_object
-          the_body
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class SomeNameSpace::TestClass
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class Some::Name::Space::TestClass
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class TestClass < Object
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class TestClass < SomeNameSpace::Object
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class TestClass
-          def foo
-            :bar
-          end
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        class ::TestClass
-        end
-      RUBY
-    end
-
-    context 'module' do
-
-      assert_source <<-RUBY
-        module TestModule
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        module SomeNameSpace::TestModule
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        module Some::Name::Space::TestModule
-        end
-      RUBY
-
-      assert_source <<-RUBY
-        module TestModule
-          def foo
-            :bar
-          end
-        end
-      RUBY
-
-    end
-
-    context 'op assign' do
-      %w(|= ||= &= &&= += -= *= /= **= %=).each do |op|
-        assert_source "self.foo #{op} bar"
-        assert_source "foo[key] #{op} bar"
-      end
-    end
-
-    context 'element assignment' do
-      assert_source 'array[index] = value'
-      assert_source 'array[*index] = value'
-
-      %w(+ - * / % & | || &&).each do |operator|
-        context "with #{operator}" do
-          assert_source "array[index] #{operator}= 2"
-          assert_source "array[] #{operator}= 2"
-        end
-      end
-    end
-
-    context 'defined?' do
-      assert_source <<-RUBY
-        defined?(@foo)
-      RUBY
-
-      assert_source <<-RUBY
-        defined?(Foo)
-      RUBY
-    end
-  end
-
-  context 'lambda' do
-    assert_source <<-RUBY
-      lambda do
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      lambda do |a, b|
-        a
-      end
-    RUBY
-  end
-
-  context 'match operators' do
-    assert_source <<-RUBY
-      /bar/ =~ foo
-    RUBY
-
-    assert_source <<-RUBY
-      foo =~ /bar/
-    RUBY
-  end
-
-  context 'binary operator methods' do
-    %w(+ - * / & | << >> == === != <= < <=> > >= =~ !~ ^ **).each do |operator|
-      rubies = RUBIES - (%w(!= !~).include?(operator) ? %w(1.8) : [])
-      assert_source "1 #{operator} 2",        rubies
-      assert_source "left.#{operator}(*foo)", rubies
-      assert_source "left.#{operator}(a, b)", rubies
-      assert_source "self #{operator} b",     rubies
-      assert_source "a #{operator} b",        rubies
-      assert_source "(a #{operator} b).foo",  rubies
-    end
-  end
-
-  context 'nested binary operators' do
-    assert_source '(a + b) / (c - d)'
-    assert_source '(a + b) / (c.-(e, f))'
-    assert_source '(a + b) / (c.-(*f))'
-  end
-
-  context 'binary operator' do
-     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)))"
-  end
-
-  context 'expansion of shortcuts' do
-    assert_source 'a += 2'
-    assert_source 'a -= 2'
-    assert_source 'a **= 2'
-    assert_source 'a *= 2'
-    assert_source 'a /= 2'
-  end
-
-  context 'shortcuts' do
-    assert_source 'a &&= b'
-    assert_source 'a ||= 2'
-    assert_source '(a ||= 2).bar'
-  end
-
-  context 'flip flops' do
-    context 'inclusive' do
-      assert_source <<-RUBY
-        if (i == 4)..(i == 4)
-          foo
-        end
-      RUBY
-    end
-
-    context 'exclusive' do
-      assert_source <<-RUBY
-        if (i == 4)...(i == 4)
-          foo
-        end
-      RUBY
-    end
-  end
-
-  context 'case statement' do
-    assert_source <<-RUBY
-      case
-      when bar
-        baz
-      when baz
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      case foo
-      when bar
-      when baz
-        bar
-      end
-    RUBY
-
-
-    assert_source <<-RUBY
-      case foo
-      when bar
-        baz
-      when baz
-        bar
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      case foo
-      when bar, baz
-        :other
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      case foo
-      when *bar
-        :value
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      case foo
-      when bar
-        baz
-      else
-        :foo
-      end
-    RUBY
-  end
-
-  context 'for' do
-    assert_source <<-RUBY
-      for a in bar do
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      for a, *b in bar do
-        baz
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      for a, b in bar do
-        baz
-      end
-    RUBY
-  end
-
-  context 'unary operators' do
-    assert_source '!1'
-    assert_source '!!1'
-    assert_source '~a'
-    assert_source '-a'
-    assert_source '+a'
-  end
-
-  context 'loop' do
-    assert_source <<-RUBY
-      loop do
-        foo
-      end
-    RUBY
-  end
-
-  context 'post conditions' do
-    assert_source <<-RUBY
-      begin
-        foo
-      end while baz
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-        bar
-      end until baz
-    RUBY
-
-    assert_source <<-RUBY
-      begin
-        foo
-        bar
-      end while baz
-    RUBY
-  end
-
-  context 'while' do
-    assert_source <<-RUBY
-      while false
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      while false
-        3
-      end
-    RUBY
-  end
-
-  context 'until' do
-    assert_source <<-RUBY
-      until false
-      end
-    RUBY
-
-    assert_source <<-RUBY
-      until false
-        3
-      end
-    RUBY
-  end
-
-end