ruby-lint 0.0.3 → 0.0.4

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

@@ -1,110 +0,0 @@
-require File.expand_path('../../../helper', __FILE__)
-
-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
-
-  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
-
-  should 'parse a class with a method' do
-    code = <<-CODE
-class Example < Foo
-  def example_method
-
-  end
-end
-    CODE
-
-    parse(code).should == s(
-      :class,
-      s(:constant, 'Example'),
-      s(:constant, 'Foo'),
-      s(
-        :body,
-        [
-          s(
-            :method_definition,
-            'example_method',
-            s(:arguments),
-            nil,
-            s(:body, [])
-          )
-        ]
-      )
-    )
-  end
-
-  should 'parse a class nested in another class' do
-    code = <<-CODE
-class First
-  class Second
-
-  end
-end
-    CODE
-
-    parse(code).should == s(
-      :class,
-      s(:constant, 'First'),
-      nil,
-      s(:body, [s(:class, s(:constant, 'Second'), nil, s(:body, []))])
-    )
-  end
-
-  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
-
-  should 'parse a class with a top level name' do
-    parse('class ::A; end').should == s(
-      :class,
-      s(:constant, 'A'),
-      nil,
-      s(:body, [])
-    )
-  end
-
-  should 'parse `class << self` blocks' do
-    code = <<-CODE
-class A
-  class << self
-    puts
-  end
-end
-    CODE
-
-    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

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

@@ -1,12 +0,0 @@
-require File.expand_path('../../../helper', __FILE__)
-
-describe 'Parsing syntax errors' do
-  should 'parse a syntax error' do
-    error = should.raise?(RubyLint::ParserError) { parse('10 <> 20') }
-
-    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

@@ -1,17 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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,217 +0,0 @@
-require File.expand_path('../../../helper', __FILE__)
-
-describe 'Parsing method calls' do
-  should 'parse a method without parameters' do
-    parse('example').should == s(
-      :method,
-      'example',
-      s(:arguments),
-      nil,
-      nil
-    )
-  end
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  should 'parse a bang! method' do
-    parse('foo!').should == s(:method, 'foo!', s(:arguments), nil, nil)
-  end
-
-  should 'parse a predicate method' do
-    parse('foo?').should == s(:method, 'foo?', s(:arguments), nil, nil)
-  end
-
-  should 'parse a method call on an object' do
-    parse('String.new').should == s(
-      :method,
-      'new',
-      s(:arguments),
-      nil,
-      s(:constant, 'String')
-    )
-  end
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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