ruby-lint 0.0.2 → 0.0.3

data/spec/ruby-lint/node.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe RubyLint::Node do
+  should 'return the value for a scalar' do
+    s(:string, 'hello').value.should == 'hello'
+  end
+
+  should 'return the value for an Array' do
+    numbers = s(:array, s(:integer, '10'), s(:integer, '20')).value
+
+    numbers.is_a?(Array).should == true
+    numbers.length.should       == 2
+
+    numbers[0].value.should == '10'
+    numbers[1].value.should == '20'
+  end
+
+  should 'return the value for a Hash' do
+    pairs = s(:hash, s(:key_value, 'number', s(:integer, '10'))).value
+
+    pairs.is_a?(Array).should == true
+
+    pairs[0].children[1].value.should == '10'
+  end
+
+  should 'return the arguments of a method' do
+    method = s(:method, 'puts', s(:arguments, s(:argument, s(:string, 'foo'))))
+
+    method.gather_arguments(:argument).length.should == 1
+
+    method.gather_arguments(:argument)[0].type.should  == :string
+    method.gather_arguments(:argument)[0].value.should == 'foo'
+  end
+
+  should 'should try to guess the Ruby class of a node' do
+    s(:string, 'foo').ruby_class.should == 'String'
+  end
+end

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

@@ -0,0 +1,225 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Parsing variable assignments' do
+  should 'parse a local variable' do
+    parse('number = 10').should == s(
+      :assign,
+      s(:local_variable, 'number'),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse an instance variable' do
+    parse('@number = 10').should == s(
+      :assign,
+      s(:instance_variable, '@number'),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse a class variable' do
+    parse('@@number = 10').should == s(
+      :assign,
+      s(:class_variable, '@@number'),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse a global variable' do
+    parse('$number = 10').should == s(
+      :assign,
+      s(:global_variable, '$number'),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse a constant' do
+    parse('NUMBER = 10').should == s(
+      :assign,
+      s(:constant, 'NUMBER'),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse a variable if it does not already have a value' do
+    parse('number ||= 10').should == s(
+      :op_assign,
+      s(:local_variable, 'number'),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse assigning two values to two variables' do
+    parse('first, second = 10, 20').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'second'), s(:integer, '20'))
+    )
+  end
+
+  should 'parse assigning one value to two variables' do
+    parse('first, second = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'second'), s(:keyword, 'nil'))
+    )
+  end
+
+  should 'parse assigning an array with two values to two variables' do
+    parse('first, second = [10, 20]').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'second'), s(:integer, '20'))
+    )
+  end
+
+  should 'parse assigning an array with one value to two variables' do
+    parse('first, second = [10]').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'second'), s(:keyword, 'nil'))
+    )
+  end
+
+  should 'parse assigning a value to a variable and expander token' do
+    parse('first, * = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10'))
+    )
+  end
+
+  should 'parse assigning two values to a variable and expander token' do
+    parse('first, * = 10, 20').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10'))
+    )
+  end
+
+  should 'parse assigning three values to two variables and an expander token' do
+    parse('first, *, second = 10, 20, 30').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'first'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'second'), s(:integer, '30'))
+    )
+  end
+
+  should 'parse assigning a single value to an expander variable' do
+    parse('*numbers = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'numbers'), s(:array, s(:integer, '10')))
+    )
+  end
+
+  should 'parse assigning two values to an expander variable' do
+    parse('*numbers = 10, 20').should == s(
+      :mass_assign,
+      s(
+        :assign,
+        s(:local_variable, 'numbers'),
+        s(:array, s(:integer, '10'), s(:integer, '20'))
+      )
+    )
+  end
+
+  should 'parse assigning a value to a local and expander variable' do
+    parse('number, *numbers = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'number'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'numbers'), s(:array))
+    )
+  end
+
+  should 'parse assigning one value to an expander and two local variables' do
+    parse('*numbers, number, numberx = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'numbers'), s(:array)),
+      s(:assign, s(:local_variable, 'number'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'numberx'), s(:keyword, 'nil'))
+    )
+
+    parse('number, *numbers, numberx = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'number'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'numbers'), s(:array)),
+      s(:assign, s(:local_variable, 'numberx'), s(:keyword, 'nil'))
+    )
+
+    parse('number, numberx, *numbers = 10').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'number'), s(:integer, '10')),
+      s(:assign, s(:local_variable, 'numberx'), s(:keyword, 'nil')),
+      s(:assign, s(:local_variable, 'numbers'), s(:array))
+    )
+  end
+
+  should 'parse assigning two values to an expander and local variable' do
+    parse('*numbers, number = 10, 20').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'numbers'), s(:array, s(:integer, '10'))),
+      s(:assign, s(:local_variable, 'number'), s(:integer, '20'))
+    )
+  end
+
+  should 'parse an uneven number of (expander) variables and values' do
+    parse('*numbers, number = 10, 20, 30').should == s(
+      :mass_assign,
+      s(
+        :assign,
+        s(:local_variable, 'numbers'),
+        s(:array, s(:integer, '10'), s(:integer, '20'))
+      ),
+      s(:assign, s(:local_variable, 'number'), s(:integer, '30'))
+    )
+
+    parse('*numbers, number = 10, 20, 30, 40').should == s(
+      :mass_assign,
+      s(
+        :assign,
+        s(:local_variable, 'numbers'),
+        s(:array, s(:integer, '10'), s(:integer, '20'), s(:integer, '30'))
+      ),
+      s(:assign, s(:local_variable, 'number'), s(:integer, '40'))
+    )
+
+    parse('number, *numbers = 10, 20, 30, 40').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'number'), s(:integer, '10')),
+      s(
+        :assign,
+        s(:local_variable, 'numbers'),
+        s(:array, s(:integer, '20'), s(:integer, '30'), s(:integer, '40'))
+      )
+    )
+
+    parse('number, *numbers, numberx = 10, 20, 30, 40').should == s(
+      :mass_assign,
+      s(:assign, s(:local_variable, 'number'), s(:integer, '10')),
+      s(
+        :assign,
+        s(:local_variable, 'numbers'),
+        s(:array, s(:integer, '20'), s(:integer, '30'))
+      ),
+      s(:assign, s(:local_variable, 'numberx'), s(:integer, '40'))
+    )
+  end
+
+  should 'parse the assignment of a attribute in a constant path' do
+    parse('Foo::Bar.example = 10').should == s(
+      :assign,
+      s(
+        :field,
+        s(:constant_path, s(:constant, 'Foo'), s(:constant, 'Bar')),
+        s(:identifier, 'example')
+      ),
+      s(:integer, '10')
+    )
+  end
+
+  should 'parse the assignment of a constant path' do
+    parse('Foo::Bar = 10').should == s(
+      :assign,
+      s(:constant_path, s(:constant, 'Foo'), s(:constant, 'Bar')),
+      s(:integer, '10')
+    )
+  end
+end

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

@@ -1,152 +1,110 @@
 require File.expand_path('../../../helper', __FILE__)
 
-describe 'RubyLint::Parser' do
-  it 'Parse a class declaration' do
-    token = RubyLint::Parser.new('class Foo; end').parse[0]
-
-    token.class.should  == RubyLint::Token::ClassToken
-    token.name.should   == ['Foo']
-    token.type.should   == :class
-    token.line.should   == 1
-    token.column.should == 6
-    token.code.should   == 'class Foo; end'
-
-    token.value.class.should  == Array
-    token.value.length.should == 0
+describe 'Parsing class definitions' do
+  should 'parse an empty class' do
+    parse('class Example; end').should == s(
+      :class,
+      s(:constant, 'Example'),
+      nil,
+      s(:body, [])
+    )
   end
 
-  it 'Parse a top level class declaration' do
-    token = RubyLint::Parser.new('class ::Foo; end').parse[0]
-
-    token.class.should == RubyLint::Token::ClassToken
-    token.name.should  == ['Foo']
-    token.type.should  == :class
+  should 'parse a class with a parent class' do
+    parse('class Example < Foo; end').should == s(
+      :class,
+      s(:constant, 'Example'),
+      s(:constant, 'Foo'),
+      s(:body, [])
+    )
   end
 
-  it 'Parse a class declaration with a parent class' do
-    token = RubyLint::Parser.new('class Foo < Bar; end').parse[0]
-
-    token.class.should  == RubyLint::Token::ClassToken
-    token.name.should   == ['Foo']
-    token.parent.should == ['Bar']
-    token.type.should   == :class
-    token.line.should   == 1
-    token.column.should == 6
-    token.code.should   == 'class Foo < Bar; end'
-
-    token.value.class.should  == Array
-    token.value.length.should == 0
-  end
-
-  it 'Parse a class declaration with multiple name segments' do
-    token = RubyLint::Parser.new('class Foo::Bar < A::B; end').parse[0]
-
-    token.class.should == RubyLint::Token::ClassToken
-    token.type.should  == :class
-    token.name.should  == ['Foo', 'Bar']
+  should 'parse a class with a method' do
+    code = <<-CODE
+class Example < Foo
+  def example_method
 
-    token.parent.should == ['A', 'B']
-    token.line.should   == 1
-    token.column.should == 6
-    token.code.should   == 'class Foo::Bar < A::B; end'
   end
+end
+    CODE
 
-  it 'Parse a top level class declaration with multiple name segments' do
-    token = RubyLint::Parser.new('class ::Foo::Bar; end').parse[0]
-
-    token.class.should  == RubyLint::Token::ClassToken
-    token.type.should   == :class
-    token.name.should   == ['Foo', 'Bar']
-    token.line.should   == 1
-    token.column.should == 8
-    token.code.should   == 'class ::Foo::Bar; end'
+    parse(code).should == s(
+      :class,
+      s(:constant, 'Example'),
+      s(:constant, 'Foo'),
+      s(
+        :body,
+        [
+          s(
+            :method_definition,
+            'example_method',
+            s(:arguments),
+            nil,
+            s(:body, [])
+          )
+        ]
+      )
+    )
   end
 
-  it 'Parse the assignments of method visibilities' do
+  should 'parse a class nested in another class' do
     code = <<-CODE
 class First
-  private
+  class Second
 
-  def private_method
-    return 'private method'
-  end
-end
-
-def public_method
-  return 'public method'
-end
-
-class Second
-  protected
-
-  def protected_method
-    return 'protected method'
   end
 end
     CODE
 
-    first, pub_method, second = RubyLint::Parser.new(code).parse
-
-    first.class.should  == RubyLint::Token::ClassToken
-    first.name.should   == ['First']
-    first.line.should   == 1
-    first.column.should == 6
-    first.code.should   == 'class First'
-
-    first.value[1].class.should      == RubyLint::Token::MethodDefinitionToken
-    first.value[1].name.should       == 'private_method'
-    first.value[1].visibility.should == :private
-    first.value[1].line.should       == 4
-    first.value[1].column.should     == 6
-    first.value[1].code.should       == '  def private_method'
-
-    pub_method.class.should      == RubyLint::Token::MethodDefinitionToken
-    pub_method.name.should       == 'public_method'
-    pub_method.visibility.should == :public
+    parse(code).should == s(
+      :class,
+      s(:constant, 'First'),
+      nil,
+      s(:body, [s(:class, s(:constant, 'Second'), nil, s(:body, []))])
+    )
+  end
 
-    second.class.should == RubyLint::Token::ClassToken
-    second.name.should  == ['Second']
+  should 'parse a class with the name as a constant path' do
+    parse('class A::B < D::E; end').should == s(
+      :class,
+      s(:constant_path, s(:constant, 'A'), s(:constant, 'B')),
+      s(:constant_path, s(:constant, 'D'), s(:constant, 'E')),
+      s(:body, [])
+    )
+  end
 
-    second.value[1].class.should      == RubyLint::Token::MethodDefinitionToken
-    second.value[1].name.should       == 'protected_method'
-    second.value[1].visibility.should == :protected
+  should 'parse a class with a top level name' do
+    parse('class ::A; end').should == s(
+      :class,
+      s(:constant, 'A'),
+      nil,
+      s(:body, [])
+    )
   end
 
-  it 'Parse the creation of methods using class << self' do
+  should 'parse `class << self` blocks' do
     code = <<-CODE
-class Person
+class A
   class << self
-    def class_method_1
-
-    end
-
-    def class_method_2
-
-    end
+    puts
   end
 end
     CODE
 
-    token = RubyLint::Parser.new(code).parse[0]
-
-    token.class.should == RubyLint::Token::ClassToken
-    token.name.should  == ['Person']
-
-    token.value.class.should  == Array
-    token.value.length.should == 2
-
-    method_1, method_2 = token.value
-
-    method_1.class.should == RubyLint::Token::MethodDefinitionToken
-    method_1.name.should  == 'class_method_1'
-
-    method_1.receiver.class.should == RubyLint::Token::VariableToken
-    method_1.receiver.name.should  == 'self'
-
-    method_2.class.should == RubyLint::Token::MethodDefinitionToken
-    method_2.name.should  == 'class_method_2'
-
-    method_2.receiver.class.should == RubyLint::Token::VariableToken
-    method_2.receiver.name.should  == 'self'
+    parse(code).should == s(
+      :class,
+      s(:constant, 'A'),
+      nil,
+      s(
+        :body,
+        [
+          s(
+            :sclass,
+            s(:keyword, 'self'),
+            s(:body, [s(:method, 'puts', s(:arguments), nil, nil)])
+          )
+        ]
+      )
+    )
   end
 end