ruby-lint 0.0.2 → 0.0.3

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

@@ -1,19 +1,12 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Parser' do
-  it 'Parse a syntax error' do
-    code = <<-CODE
-def example
-  -
-end
-    CODE
-
-    error = should.raise?(RubyLint::ParserError) do
-      RubyLint::Parser.new(code).parse
-    end
+describe 'Parsing syntax errors' do
+  should 'parse a syntax error' do
+    error = should.raise?(RubyLint::ParserError) { parse('10 <> 20') }
 
-    error.file.should   == '(ruby-lint)'
-    error.line.should   == 3
-    error.column.should == 3
+    error.message.should == "syntax error, unexpected '>'"
+    error.line.should    == 1
+    error.column.should  == 5
+    error.file.should    == '(ruby-lint)'
   end
 end

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

@@ -0,0 +1,17 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Setting metadata for AST nodes' do
+  code = <<-CODE
+# Note that space, it is required to test the column number.
+ number
+  CODE
+
+  should 'set the correct line number' do
+    node = parse(code)
+
+    node.type.should   == :method
+    node.line.should   == 2
+    node.column.should == 1
+    node.file.should   == '(ruby-lint)'
+  end
+end

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

@@ -0,0 +1,111 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Parsing method definitions' do
+  should 'parse a method without parameters' do
+    parse('def example_method; 10; end').should == s(
+      :method_definition,
+      'example_method',
+      s(:arguments),
+      nil,
+      s(:body, [s(:integer, '10')])
+    )
+  end
+
+  should 'parse a method with one required parameter' do
+    parse('def example_method(name); name; end').should == s(
+      :method_definition,
+      'example_method',
+      s(:arguments, s(:argument, s(:local_variable, 'name'))),
+      nil,
+      s(:body, [s(:local_variable, 'name')])
+    )
+  end
+
+  should 'parse a method with one required and optional parameter' do
+    parse('def example_method(name, number = 10); name; end').should == s(
+      :method_definition,
+      'example_method',
+      s(
+        :arguments,
+        s(:argument, s(:local_variable, 'name')),
+        s(:optional_argument, s(:local_variable, 'number', s(:integer, '10')))
+      ),
+      nil,
+      s(:body, [s(:local_variable, 'name')])
+    )
+  end
+
+  should 'parse a method with one required and a rest parameter' do
+    code = <<-CODE
+def example_method(name, *rest)
+  name
+end
+    CODE
+
+    parse(code).should == s(
+      :method_definition,
+      'example_method',
+      s(
+        :arguments,
+        s(:argument, s(:local_variable, 'name')),
+        s(:rest_argument, s(:local_variable, 'rest'))
+      ),
+      nil,
+      s(:body, [s(:local_variable, 'name')])
+    )
+  end
+
+  should 'parse a method with one required, optional and rest parameter' do
+    code = <<-CODE
+def example_method(name, number = 10, *rest)
+  name
+end
+    CODE
+
+    parse(code).should == s(
+      :method_definition,
+      'example_method',
+      s(
+        :arguments,
+        s(:argument, s(:local_variable, 'name')),
+        s(:optional_argument, s(:local_variable, 'number', s(:integer, '10'))),
+        s(:rest_argument, s(:local_variable, 'rest'))
+      ),
+      nil,
+      s(:body, [s(:local_variable, 'name')])
+    )
+  end
+
+  should 'parse a method with all parameter types' do
+    code = <<-CODE
+def example_method(name, number = 10, *rest, more, &block)
+  name
+end
+    CODE
+
+    parse(code).should == s(
+      :method_definition,
+      'example_method',
+      s(
+        :arguments,
+        s(:argument, s(:local_variable, 'name')),
+        s(:optional_argument, s(:local_variable, 'number', s(:integer, '10'))),
+        s(:rest_argument, s(:local_variable, 'rest')),
+        s(:more_argument, s(:local_variable, 'more')),
+        s(:block_argument, s(:local_variable, 'block'))
+      ),
+      nil,
+      s(:body, [s(:local_variable, 'name')])
+    )
+  end
+
+  should 'parse defining a class method on a receiver' do
+    parse('def String.example_method; end').should == s(
+      :method_definition,
+      'example_method',
+      s(:arguments),
+      s(:constant, 'String'),
+      s(:body, [])
+    )
+  end
+end

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

@@ -1,249 +1,217 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Parser' do
-  it 'Parse a method definition' do
-    token = RubyLint::Parser.new('def number; return 10; end').parse[0]
-
-    token.class.should      == RubyLint::Token::MethodDefinitionToken
-    token.line.should       == 1
-    token.column.should     == 4
-    token.name.should       == 'number'
-    token.visibility.should == :public
-    token.type.should       == :method_definition
-
-    token.parameters.class.should == RubyLint::Token::ParametersToken
-
-    token.value.class.should  == Array
-    token.value.length.should == 1
-
-    token.value[0].class.should == RubyLint::Token::StatementToken
-    token.value[0].type.should  == :return
-
-    token.value[0].value.class.should  == Array
-    token.value[0].value.length.should == 1
-
-    value = token.value[0].value[0]
-
-    value.class.should == RubyLint::Token::Token
-    value.type.should  == :integer
-    value.value.should == '10'
+describe 'Parsing method calls' do
+  should 'parse a method without parameters' do
+    parse('example').should == s(
+      :method,
+      'example',
+      s(:arguments),
+      nil,
+      nil
+    )
   end
 
-  it 'Parse a method definition with parameters' do
-    code = <<-CODE
-def number(a, b = 10, *args, more, &block)
-  return num
-end
-    CODE
-
-    token = RubyLint::Parser.new(code).parse[0]
-
-    token.class.should  == RubyLint::Token::MethodDefinitionToken
-    token.name.should   == 'number'
-    token.line.should   == 1
-    token.column.should == 4
-
-    params = token.parameters
-
-    params.class.should       == RubyLint::Token::ParametersToken
-    params.value.class.should == Array
-
-    # Required parameters
-    params.value.length.should    == 1
-    params.value[0].class.should  == RubyLint::Token::VariableToken
-    params.value[0].name.should   == 'a'
-
-    # Optional parameters
-    params.optional.class.should  == Array
-    params.optional.length.should == 1
-
-    optional = params.optional[0]
-
-    optional.class.should  == RubyLint::Token::VariableToken
-    optional.name.should   == 'b'
-
-    optional.value.class.should == RubyLint::Token::Token
-    optional.value.type.should  == :integer
-    optional.value.value.should == '10'
-
-    # Rest parameters
-    params.rest.name.should  == 'args'
-    params.rest.class.should == RubyLint::Token::VariableToken
-
-    # More parameters
-    params.more.class.should   == Array
-    params.more.length.should  == 1
-    params.more[0].name.should == 'more'
-
-    # Block parameters
-    params.block.class.should == RubyLint::Token::VariableToken
-    params.block.name.should  == 'block'
+  should 'parse a method with two parameters' do
+    parse('example "foo", 10').should == s(
+      :method,
+      'example',
+      s(
+        :arguments,
+        s(:argument, s(:string, 'foo')),
+        s(:argument, s(:integer, '10'))
+      ),
+      nil,
+      nil
+    )
   end
 
-  it 'Parse a class method definition' do
-    code = <<-CODE
-def self.example(number = 10)
-  return number
-end
-    CODE
-
-    token = RubyLint::Parser.new(code).parse[0]
-
-    token.class.should == RubyLint::Token::MethodDefinitionToken
-    token.name.should  == 'example'
-
-    token.receiver.class.should == RubyLint::Token::VariableToken
-    token.receiver.name.should  == 'self'
-    token.receiver.type.should  == :keyword
-
-    token.operator.class.should == RubyLint::Token::Token
-    token.operator.value.should == '.'
-    token.operator.type.should  == :period
-
-    token.parameters.class.should           == RubyLint::Token::ParametersToken
-    token.parameters.optional.class.should  == Array
-    token.parameters.optional.length.should == 1
+  should 'parse a method with parenthesis and two parameters' do
+    parse('example("foo", 10)').should == s(
+      :method,
+      'example',
+      s(
+        :arguments,
+        s(:argument, s(:string, 'foo')),
+        s(:argument, s(:integer, '10'))
+      ),
+      nil,
+      nil
+    )
   end
 
-  it 'Parse a private method definition' do
-    code = <<-CODE
-private
-
-def example
-  return 10
-end
-    CODE
-
-    token = RubyLint::Parser.new(code).parse[1]
-
-    token.class.should      == RubyLint::Token::MethodDefinitionToken
-    token.name.should       == 'example'
-    token.visibility.should == :private
-
-    token.value.class.should  == Array
-    token.value.length.should == 1
+  should 'parse a proc with a block without parameters' do
+    parse('proc { }').should == s(
+      :method,
+      'proc',
+      s(:arguments),
+      s(:block, s(:arguments), s(:body, [])),
+      nil
+    )
   end
 
-  it 'Parse a method call' do
-    token = RubyLint::Parser.new('puts').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'puts'
+  should 'parse a proc with a block using curly braces' do
+    parse('proc { |example| example }').should == s(
+      :method,
+      'proc',
+      s(:arguments),
+      s(
+        :block,
+        s(:arguments, s(:argument, s(:local_variable, 'example'))),
+        s(:body, [s(:local_variable, 'example')])
+      ),
+      nil
+    )
   end
 
-  it 'Parse a method call with parenthesis' do
-    token = RubyLint::Parser.new('puts()').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'puts'
+  should 'parse a proc with a block using do/end' do
+    parse('proc do |example|; example; end').should == s(
+      :method,
+      'proc',
+      s(:arguments),
+      s(
+        :block,
+        s(:arguments, s(:argument, s(:local_variable, 'example'))),
+        s(:body, [s(:local_variable, 'example')])
+      ),
+      nil
+    )
   end
 
-  it 'Parse a method call with parenthesis and parameters' do
-    token = RubyLint::Parser.new('puts(10)').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'puts'
-
-    token.parameters.class.should  == Array
-    token.parameters.length.should == 1
-
-    param = token.parameters[0]
-
-    param.class.should == RubyLint::Token::Token
-    param.type.should  == :integer
-    param.value.should == '10'
+  should 'parse a lambda with a block using curly braces' do
+    parse('lambda { |example| example }').should == s(
+      :method,
+      'lambda',
+      s(:arguments),
+      s(
+        :block,
+        s(:arguments, s(:argument, s(:local_variable, 'example'))),
+        s(:body, [s(:local_variable, 'example')])
+      ),
+      nil
+    )
   end
 
-  it 'Parse a method call with parameters but without parenthesis' do
-    token = RubyLint::Parser.new('puts 10').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'puts'
-
-    token.parameters.class.should  == Array
-    token.parameters.length.should == 1
-
-    param = token.parameters[0]
-
-    param.class.should == RubyLint::Token::Token
-    param.type.should  == :integer
-    param.value.should == '10'
+  should 'parse a method with a parameter and a block' do
+    parse('foo(10) { |name| name }').should == s(
+      :method,
+      'foo',
+      s(:arguments, s(:argument,  s(:integer, '10'))),
+      s(
+        :block,
+        s(:arguments, s(:argument, s(:local_variable, 'name'))),
+        s(:body, [s(:local_variable, 'name')])
+      ),
+      nil
+    )
   end
 
-  it 'Parse a method called on an object with parenthesis' do
-    token = RubyLint::Parser.new('Struct.new(:name)').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'new'
-
-    token.receiver.class.should == RubyLint::Token::VariableToken
-    token.receiver.type.should  == :constant
-    token.receiver.name.should  == 'Struct'
-
-    token.parameters.class.should  == Array
-    token.parameters.length.should == 1
-
-    token.parameters[0].class.should == RubyLint::Token::Token
-    token.parameters[0].type.should  == :symbol
-    token.parameters[0].value.should == 'name'
+  should 'parse a bang! method' do
+    parse('foo!').should == s(:method, 'foo!', s(:arguments), nil, nil)
   end
 
-  it 'Parse a method called on an object without parenthesis' do
-    token = RubyLint::Parser.new('Struct.new :name').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'new'
-
-    token.receiver.class.should == RubyLint::Token::VariableToken
-    token.receiver.type.should  == :constant
-    token.receiver.name.should  == 'Struct'
-
-    token.parameters.class.should  == Array
-    token.parameters.length.should == 1
-
-    token.parameters[0].class.should == RubyLint::Token::Token
-    token.parameters[0].type.should  == :symbol
-    token.parameters[0].value.should == 'name'
+  should 'parse a predicate method' do
+    parse('foo?').should == s(:method, 'foo?', s(:arguments), nil, nil)
   end
 
-  it 'Parse a method called on an object with a block passed' do
-    token = RubyLint::Parser.new('Foo.bar { |example| example }').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
-    token.name.should  == 'bar'
-
-    token.receiver.class.should == RubyLint::Token::VariableToken
-    token.receiver.type.should  == :constant
-    token.receiver.name.should  == 'Foo'
-
-    token.block.class.should            == RubyLint::Token::BlockToken
-    token.block.parameters.class.should == RubyLint::Token::ParametersToken
-
-    token.block.parameters.value.class.should  == Array
-    token.block.parameters.value.length.should == 1
+  should 'parse a method call on an object' do
+    parse('String.new').should == s(
+      :method,
+      'new',
+      s(:arguments),
+      nil,
+      s(:constant, 'String')
+    )
   end
 
-  it 'Parse a method call with a bare Hash as a parameter' do
-    token = RubyLint::Parser.new('language(:name => "Ruby")').parse[0]
-
-    token.class.should == RubyLint::Token::MethodToken
+  should 'parse a method call on an object with a parameter' do
+    parse('String.new(10)').should == s(
+      :method,
+      'new',
+      s(:arguments, s(:argument,  s(:integer, '10'))),
+      nil,
+      s(:constant, 'String')
+    )
+  end
 
-    token.parameters.class.should  == Array
-    token.parameters.length.should == 1
+  should 'parse a method call on an object without parenthesis' do
+    parse('String.new 10').should == s(
+      :method,
+      'new',
+      s(:arguments, s(:argument,  s(:integer, '10'))),
+      nil,
+      s(:constant, 'String')
+    )
+  end
 
-    token.parameters[0].class.should == RubyLint::Token::Token
-    token.parameters[0].type.should  == :hash
+  should 'parse a method call on an object with a parameter and a block' do
+    parse('String.new(10) { |name| name }').should == s(
+      :method,
+      'new',
+      s(:arguments, s(:argument,  s(:integer, '10'))),
+      s(
+        :block,
+        s(:arguments, s(:argument, s(:local_variable, 'name'))),
+        s(:body, [s(:local_variable, 'name')])
+      ),
+      s(:constant, 'String')
+    )
   end
 
-  it 'Parse a method call with a bare JSON style Hash as a parameter' do
-    token = RubyLint::Parser.new('language(name: "Ruby")').parse[0]
+  should 'parse a method call with a Hash as the parameter' do
+    parse('foo(:name => "Ruby")').should == s(
+      :method,
+      'foo',
+      s(
+        :arguments,
+        s(
+          :argument,
+          s(:hash, s(:key_value, s(:symbol, 'name'), s(:string, 'Ruby')))
+        )
+      ),
+      nil,
+      nil
+    )
+  end
 
-    token.class.should == RubyLint::Token::MethodToken
+  should 'parse a method call with a block parameter' do
+    parse('foo(&bar)').should == s(
+      :method,
+      'foo',
+      s(
+        :arguments,
+        s(:block_argument, s(:method, 'bar', s(:arguments), nil, nil))
+      ),
+      nil,
+      nil
+    )
+  end
 
-    token.parameters.class.should  == Array
-    token.parameters.length.should == 1
+  should 'parse a method call with a splat argument' do
+    parse('foo(example, *numbers)').should == s(
+      :method,
+      'foo',
+      s(
+        :arguments,
+        s(:argument, s(:method, 'example', s(:arguments), nil, nil)),
+        s(:splat_argument, s(:method, 'numbers', s(:arguments), nil, nil))
+      ),
+      nil,
+      nil
+    )
+  end
 
-    token.parameters[0].class.should == RubyLint::Token::Token
-    token.parameters[0].type.should  == :hash
+  should 'parse a method call with multiple splat arguments' do
+    parse('foo(*a, b, *c)').should == s(
+      :method,
+      'foo',
+      s(
+        :arguments,
+        s(:splat_argument, s(:method, 'a', s(:arguments), nil, nil)),
+        s(:argument, s(:method, 'b', s(:arguments), nil, nil)),
+        s(:splat_argument, s(:method, 'c', s(:arguments), nil, nil)),
+      ),
+      nil,
+      nil
+    )
   end
 end