ruby-lint 0.0.2 → 0.0.3

data/spec/ruby-lint/parser/modules.rb

@@ -1,49 +1,70 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Parser' do
-  it 'Parse a module' do
+describe 'Parsing module definitions' do
+  should 'parse an empty module' do
+    parse('module Example; end').should == s(
+      :module,
+      s(:constant, 'Example'),
+      s(:body, [])
+    )
+  end
+
+  should 'parse a module with a method' do
     code = <<-CODE
-module Foo
-  def foo
-    return 'foo'
+module Example
+  def example_method
+
   end
 end
     CODE
 
-    token = RubyLint::Parser.new(code).parse[0]
-
-    token.class.should  == RubyLint::Token::Token
-    token.type.should   == :module
-    token.name.should   == ['Foo']
-    token.line.should   == 1
-    token.column.should == 7
-
-    token.value.class.should  == Array
-    token.value.length.should == 1
-
-    token.value[0].class.should == RubyLint::Token::MethodDefinitionToken
-    token.value[0].name.should  == 'foo'
+    parse(code).should == s(
+      :module,
+      s(:constant, 'Example'),
+      s(
+        :body,
+        [
+          s(
+            :method_definition,
+            'example_method',
+            s(:arguments),
+            nil,
+            s(:body, [])
+          )
+        ]
+      )
+    )
   end
 
-  it 'Parse a module with multiple name segments' do
-    token = RubyLint::Parser.new('module A::B; end').parse[0]
-
-    token.class.should == RubyLint::Token::Token
-    token.type.should  == :module
-    token.name.should  == ['A', 'B']
+  should 'parse a nested module' do
+    code = <<-CODE
+module A
+  module B
 
-    token.line.should   == 1
-    token.column.should == 7
   end
+end
+    CODE
 
-  it 'Parse a top level module' do
-    token = RubyLint::Parser.new('module ::A::B; end').parse[0]
+    parse(code).should == s(
+      :module,
+      s(:constant, 'A'),
+      s(:body, [s(:module, s(:constant, 'B'), s(:body, []))])
+    )
+  end
 
-    token.class.should == RubyLint::Token::Token
-    token.type.should  == :module
-    token.name.should  == ['A', 'B']
+  should 'parse a module with a constant path as the name' do
+    parse('module Foo::Bar; end').should == s(
+      :module,
+      s(:constant_path, s(:constant, 'Foo'), s(:constant, 'Bar')),
+      s(:body, [])
+    )
+  end
 
-    token.line.should   == 1
-    token.column.should == 9
+  should 'parse a module with a top level name' do
+    parse('module ::Foo; end').should == s(
+      :module,
+      s(:constant, 'Foo'),
+      s(:body, [])
+    )
   end
 end

data/spec/ruby-lint/parser/operators.rb

@@ -1,75 +1,40 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Parser' do
-  it 'Parse the use of various operators' do
-    ['*', '-', '+', '/', '%', '^'].each do |operator|
-      token = RubyLint::Parser.new("10 #{operator} 2").parse[0]
-
-      token.class.should  == RubyLint::Token::Token
-      token.type.should   == :binary
-
-      token.value.class.should  == Array
-      token.value.length.should == 3
-
-      left, op, right = token.value
-
-      left.class.should == RubyLint::Token::Token
-      left.type.should  == :integer
-      left.value.should == '10'
-
-      op.should == operator.to_sym
-
-      right.class.should == RubyLint::Token::Token
-      right.type.should  == :integer
-      right.value.should == '2'
+describe 'Parsing operators' do
+  it 'should parse various basic operators' do
+    [:*, :-, :+, :/, :%, :^, :and, :'&&', :or, :'||'].each do |op|
+      parse("10 #{op} 2").should == s(
+        :binary,
+        s(:integer, '10'),
+        op,
+        s(:integer, '2')
+      )
     end
   end
 
-  it 'Parse the use of multiple operators' do
-    token = RubyLint::Parser.new('10 and 20 and 30').parse[0]
-
-    token.class.should  == RubyLint::Token::Token
-    token.type.should   == :binary
-
-    token.value.class.should  == Array
-    token.value.length.should == 3
-
-    first = token.value[0]
-    last  = token.value[2]
-
-    first.class.should        == RubyLint::Token::Token
-    first.type.should         == :binary
-    first.value.length.should == 3
-
-    first.value[0].class.should == RubyLint::Token::Token
-    first.value[0].type.should  == :integer
-    first.value[0].value.should == '10'
-
-    first.value[1].should == :and
-
-    first.value[2].class.should == RubyLint::Token::Token
-    first.value[2].type.should  == :integer
-    first.value[2].value.should == '20'
-
-    token.value[1].should == :and
-
-    last.class.should == RubyLint::Token::Token
-    last.type.should  == :integer
-    last.value.should == '30'
+  should 'parse the use of multiple operators at once' do
+    parse('10 and 20 and 30').should == s(
+      :binary,
+      s(:binary, s(:integer, '10'), :and, s(:integer, '20')),
+      :and,
+      s(:integer, '30')
+    )
   end
 
-  it 'Parse unary operators' do
-    token = RubyLint::Parser.new('!foobar').parse[0]
-
-    token.class.should == RubyLint::Token::Token
-    token.type.should  == :unary
-
-    token.value.class.should  == Array
-    token.value.length.should == 2
-
-    token.value[0].should == :!
+  should 'parse a unary operator' do
+    parse('!foobar').should == s(
+      :unary,
+      :!,
+      s(:method, 'foobar', s(:arguments), nil, nil)
+    )
+  end
 
-    token.value[1].class.should == RubyLint::Token::MethodToken
-    token.value[1].name.should  == 'foobar'
+  should 'parse a ternary operator' do
+    parse('statement ? true : false').should == s(
+      :ternary,
+      s(:method, 'statement', s(:arguments), nil, nil),
+      s(:keyword, 'true'),
+      s(:keyword, 'false')
+    )
   end
 end

data/spec/ruby-lint/parser/statements/begin.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing begin/rescue statements' do
+  should 'parse a multi line statement' do
+    code = <<-CODE
+begin
+  rescue_body
+rescue Foo
+  foo_body
+rescue Bar, Baz => e
+  bar_baz_body
+else
+  else_body
+ensure
+  ensure_body
+end
+    CODE
+
+    parse(code).should == s(
+      :begin,
+      s(
+        :body,
+        [s(:method, 'rescue_body', s(:arguments), nil, nil)],
+        [
+          s(
+            :rescue,
+            nil,
+            [s(:constant, 'Foo')],
+            nil,
+            [s(:method, 'foo_body', s(:arguments), nil, nil)]
+          ),
+          s(
+            :rescue,
+            nil,
+            [s(:constant, 'Bar'), s(:constant, 'Baz')],
+            s(:local_variable, 'e'),
+            [s(:method, 'bar_baz_body', s(:arguments), nil, nil)]
+          )
+        ],
+        s(:else, s(:method, 'else_body', s(:arguments), nil, nil)),
+        s(:ensure, s(:method, 'ensure_body', s(:arguments), nil, nil))
+      )
+    )
+  end
+
+  should 'parse a single line statement' do
+    parse('foo rescue bar').should == s(
+      :rescue,
+      s(:method, 'foo', s(:arguments), nil, nil),
+      nil,
+      nil,
+      s(:method, 'bar', s(:arguments), nil, nil)
+    )
+  end
+end

data/spec/ruby-lint/parser/statements/case.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing case statements' do
+  should 'parse a case statement' do
+    code = <<-CODE
+case number
+when 10, 20
+  '10 or 20'
+when 30
+  '30'
+else
+  'something else'
+end
+    CODE
+
+    parse(code).should == s(
+      :case,
+      s(:method, 'number', s(:arguments), nil, nil),
+      [
+        s(
+          :when,
+          [s(:integer, '10'), s(:integer, '20')],
+          [s(:string, '10 or 20')]
+        ),
+        s(
+          :when,
+          [s(:integer, '30')],
+          [s(:string, '30')]
+        )
+      ],
+      s(:else, s(:string, 'something else'))
+    )
+  end
+end

data/spec/ruby-lint/parser/statements/defined.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing defined? statements' do
+  should 'parse a defined? statement' do
+    parse('defined? Kernel').should == s(:defined, s(:constant, 'Kernel'))
+  end
+
+  should 'parse a defined?() statement' do
+    parse('defined?(Kernel)').should == s(:defined, s(:constant, 'Kernel'))
+  end
+end

data/spec/ruby-lint/parser/statements/for.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing for loops' do
+  should 'parse a loop with a single variable' do
+    code = <<-CODE
+for foo in bar
+  foo
+end
+    CODE
+
+    parse(code).should == s(
+      :for,
+      [s(:local_variable, 'foo')],
+      s(:method, 'bar', s(:arguments), nil, nil),
+      [s(:local_variable, 'foo')]
+    )
+  end
+
+  should 'parse a loop with two variables' do
+    code = <<-CODE
+for key, value in bar
+  key
+  value
+end
+    CODE
+
+    parse(code).should == s(
+      :for,
+      [s(:local_variable, 'key'), s(:local_variable, 'value')],
+      s(:method, 'bar', s(:arguments), nil, nil),
+      [s(:local_variable, 'key'), s(:local_variable, 'value')]
+    )
+  end
+end

data/spec/ruby-lint/parser/statements/if.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing if statements' do
+  should 'parse a multi line statement' do
+    code = <<-CODE
+if foo
+  bar
+elsif first
+  first
+elsif second
+  second
+else
+  baz
+end
+    CODE
+
+    parse(code).should == s(
+      :if,
+      s(:method, 'foo', s(:arguments), nil, nil),
+      [s(:method, 'bar', s(:arguments), nil, nil)],
+      [
+        s(
+          :elsif,
+          s(:method, 'first', s(:arguments), nil, nil),
+          [s(:method, 'first', s(:arguments), nil, nil)]
+        ),
+        s(
+          :elsif,
+          s(:method, 'second', s(:arguments), nil, nil),
+          [s(:method, 'second', s(:arguments), nil, nil)]
+        ),
+      ],
+      s(:else, s(:method, 'baz', s(:arguments), nil, nil))
+    )
+  end
+
+  should 'parse a single line statement' do
+    parse('bar if foo').should == s(
+      :if,
+      s(:method, 'foo', s(:arguments), nil, nil),
+      [s(:method, 'bar', s(:arguments), nil, nil)],
+      [],
+      nil
+    )
+  end
+end

data/spec/ruby-lint/parser/statements/return.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing return statements' do
+  should 'parse a statement with two parameters' do
+    parse('return 10, 20').should == s(
+      :return,
+      s(
+        :arguments,
+        s(:argument, s(:integer, '10')),
+        s(:argument, s(:integer, '20'))
+      )
+    )
+  end
+end

data/spec/ruby-lint/parser/statements/super.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing super statements' do
+  should 'parse a statement without parameters' do
+    parse('super').should == s(:super, nil)
+  end
+
+  should 'parse a statement with parameters' do
+    parse('super 10, 20').should == s(
+      :super,
+      s(
+        :arguments,
+        s(:argument, s(:integer, '10')),
+        s(:argument, s(:integer, '20'))
+      )
+    )
+  end
+
+  should 'parse a statement with parenthesis' do
+    parse('super()').should == s(:super, nil)
+  end
+
+  should 'parse a statement with parenthesis and parameters' do
+    parse('super(10, 20)').should == s(
+      :super,
+      s(
+        :arguments,
+        s(:argument, s(:integer, '10')),
+        s(:argument, s(:integer, '20'))
+      )
+    )
+  end
+
+  should 'parse a statement with a block' do
+    parse('super do; end').should == s(
+      :super,
+      nil,
+      s(:block, s(:arguments), s(:body, []))
+    )
+  end
+
+  should 'parse a statement with a block and parameters' do
+    parse('super 10 do; end').should == s(
+      :super,
+      s(:arguments, s(:argument, s(:integer, '10'))),
+      s(:block, s(:arguments), s(:body, []))
+    )
+  end
+end