ruby-lint 0.0.2 → 0.0.3

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

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

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

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

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

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

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

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

data/spec/ruby-lint/parser/types/arrays.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Arrays' do
+  should 'parse an array with integers' do
+    parse('[10, 20]').should == s(:array, s(:integer, '10'), s(:integer, '20'))
+  end
+
+  should 'parse an array with strings using %w{}' do
+    parse('%w{10 20}').should == s(:array, s(:string, '10'), s(:string, '20'))
+  end
+
+  should 'parse an array with strings using %W{}' do
+    parse('%W{10 20}').should == s(:array, s(:string, '10'), s(:string, '20'))
+  end
+
+  should 'parse referencing an index of an array directly' do
+    parse('[10][0]').should == s(
+      :aref,
+      s(:array, s(:integer, '10')),
+      s(:arguments, s(:argument, s(:integer, '0')))
+    )
+  end
+
+  should 'parse referencing multiple indexes of an array directly' do
+    parse('[10][0,1]').should == s(
+      :aref,
+      s(:array, s(:integer, '10')),
+      s(
+        :arguments,
+        s(:argument, s(:integer, '0')),
+        s(:argument, s(:integer, '1'))
+      )
+    )
+  end
+
+  should 'parse assigning a value to an array index' do
+    parse('[][0] = 10').should == s(
+      :assign,
+      s(
+        :aref,
+        s(:array),
+        s(:arguments, s(:argument, s(:integer, '0')))
+      ),
+      [s(:integer, '10')]
+    )
+  end
+end

data/spec/ruby-lint/parser/types/booleans.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing booleans' do
+  should 'parse a TrueClass' do
+    parse('true').should == s(:keyword, 'true')
+  end
+
+  should 'parse a Falseclass' do
+    parse('false').should == s(:keyword, 'false')
+  end
+end

data/spec/ruby-lint/parser/types/constants.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing constants' do
+  should 'parse a constant' do
+    parse('String').should == s(:constant, 'String')
+  end
+
+  should 'parse a constant path' do
+    parse('Foo::Bar').should == s(
+      :constant_path,
+      s(:constant, 'Foo'),
+      s(:constant, 'Bar')
+    )
+  end
+
+  should 'parse a constant path with more than two segments' do
+    parse('A::B::C').should == s(
+      :constant_path,
+      s(:constant, 'A'),
+      s(:constant, 'B'),
+      s(:constant, 'C')
+    )
+  end
+
+  should 'parse a top level constant path' do
+    parse('::Foo::Bar').should == s(
+      :constant_path,
+      s(:constant, 'Foo'),
+      s(:constant, 'Bar')
+    )
+  end
+end

data/spec/ruby-lint/parser/types/hashes.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Hashes' do
+  should 'parse a hash with the keys as strings' do
+    parse('{"name" => "Ruby", "foo" => "Bar"}').should == s(
+      :hash,
+      s(:key_value, s(:string, 'name'), s(:string, 'Ruby')),
+      s(:key_value, s(:string, 'foo'), s(:string, 'Bar'))
+    )
+  end
+
+  should 'parse a hash with the keys as symbols' do
+    parse('{:name => "Ruby", :foo => "Bar"}').should == s(
+      :hash,
+      s(:key_value, s(:symbol, 'name'), s(:string, 'Ruby')),
+      s(:key_value, s(:symbol, 'foo'), s(:string, 'Bar'))
+    )
+  end
+
+  should 'parse Ruby 1.9 key syntax' do
+    parse('{name: "Ruby", foo: "Bar"}').should == s(
+      :hash,
+      s(:key_value, s(:symbol, 'name:'), s(:string, 'Ruby')),
+      s(:key_value, s(:symbol, 'foo:'), s(:string, 'Bar'))
+    )
+  end
+
+  should 'parse a hash key reference using a string' do
+    parse('{"name" => "Ruby"}["name"]').should == s(
+      :aref,
+      s(:hash, s(:key_value, s(:string, 'name'), s(:string, 'Ruby'))),
+      s(:arguments, s(:argument, s(:string, 'name')))
+    )
+  end
+
+  should 'parse a hash key reference using a symbol' do
+    parse('{"name" => "Ruby"}[:name]').should == s(
+      :aref,
+      s(:hash, s(:key_value, s(:string, 'name'), s(:string, 'Ruby'))),
+      s(:arguments, s(:argument, s(:symbol, 'name')))
+    )
+  end
+
+  should 'parse the assignment to multiple hash keys' do
+    parse('{}[:name] = "Ruby"').should == s(
+      :assign,
+      s(
+        :aref,
+        s(:hash),
+        s(:arguments, s(:argument, s(:symbol, 'name')))
+      ),
+      [s(:string, 'Ruby')]
+    )
+  end
+end

data/spec/ruby-lint/parser/types/nil.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing nil values' do
+  should 'parse NilClass' do
+    parse('nil').should == s(:keyword, 'nil')
+  end
+end

data/spec/ruby-lint/parser/types/numbers.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing numbers' do
+  should 'parse a integer' do
+    parse('10').should == s(:integer, '10')
+  end
+
+  should 'parse a float' do
+    parse('10.5').should == s(:float, '10.5')
+  end
+end

data/spec/ruby-lint/parser/types/procs.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Lambdas' do
+  should 'parse the dash rocket syntax' do
+    parse('-> example { example }').should == s(
+      :lambda,
+      s(:arguments, s(:argument, s(:local_variable, 'example'))),
+      s(:body, [s(:local_variable, 'example')])
+    )
+  end
+end

data/spec/ruby-lint/parser/types/ranges.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Ranges' do
+  should 'parse a range created using two dots' do
+    parse('0..1').should == s(:dot2, s(:integer, '0'), s(:integer, '1'))
+  end
+
+  should 'parse a range created using three dots' do
+    parse('0...1').should == s(:dot3, s(:integer, '0'), s(:integer, '1'))
+  end
+end

data/spec/ruby-lint/parser/types/regexp.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Regexps' do
+  should 'parse a regular expression without a mode' do
+    parse('/foo/').should == s(
+      :regexp,
+      s(:string, 'foo'),
+      s(:regexp_end, '/')
+    )
+  end
+
+  should 'parse a regular expression with two modes' do
+    parse('/foo/im').should == s(
+      :regexp,
+      s(:string, 'foo'),
+      s(:regexp_end, '/im')
+    )
+  end
+
+  should 'parse a regular expression created using %r{}' do
+    parse('%r{foo}').should == s(
+      :regexp,
+      s(:string, 'foo'),
+      s(:regexp_end, '}')
+    )
+  end
+end

data/spec/ruby-lint/parser/types/strings.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Strings' do
+  should 'parse an empty string' do
+    parse('""').should == s(:string)
+  end
+
+  should 'parse a string using single quotes' do
+    parse("'hello'").should == s(:string, 'hello')
+  end
+
+  should 'parse a string using double quotes' do
+    parse('"hello"').should == s(:string, 'hello')
+  end
+
+  should 'parse a string created using %q{}' do
+    parse('%q{hello world}').should == s(:string, 'hello world')
+  end
+
+  should 'parse a string created using %Q{}' do
+    parse('%Q{hello world}').should == s(:string, 'hello world')
+  end
+
+  should 'parse a string containing an embedded expression' do
+    parse('"#{10}"').should == s(:embed, s(:integer, '10'))
+  end
+
+  should 'parse a string containing an embedded expression using a shorthand' do
+    parse('"#$foo"').should == s(:embed, s(:global_variable, '$foo'))
+  end
+
+  should 'parse a string spread out over two lines using backslashes' do
+    code = <<-CODE
+'hello' \
+  'world'
+    CODE
+
+    parse(code).should == s(
+      :string_concat,
+      s(:string, 'hello'),
+      s(:string, 'world')
+    )
+  end
+end

data/spec/ruby-lint/parser/types/symbols.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Parsing Symbols' do
+  should 'parse a symbol without quotes' do
+    parse(':hello').should == s(:symbol, 'hello')
+  end
+
+  should 'parse a symbol with quotes' do
+    parse(':"hello"').should == s(:symbol, 'hello')
+  end
+
+  should 'parse an instance variable as the symbol name' do
+    parse(':@name').should == s(:symbol, '@name')
+  end
+end

data/spec/ruby-lint/presenter/json.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../../helper', __FILE__)
+require 'json'
+
+describe RubyLint::Presenter::JSON do
+  should 'format a set of entries' do
+    report    = RubyLint::Report.new
+    presenter = RubyLint::Presenter::JSON.new
+
+    report.error('error message', 1, 1, 'a.rb')
+    report.error('error message 2', 2, 1, 'a.rb')
+    report.warning('warning message', 1, 1, 'b.rb')
+    report.info('info message', 1, 1, 'c.rb')
+
+    output  = presenter.present(report)
+    decoded = JSON(output)
+
+    decoded.length.should == 4
+
+    decoded[0]['file'].should  == 'a.rb'
+    decoded[0]['level'].should == 'error'
+
+    decoded[1]['file'].should  == 'a.rb'
+    decoded[1]['level'].should == 'error'
+
+    decoded[2]['file'].should  == 'b.rb'
+    decoded[2]['level'].should == 'warning'
+
+    decoded[3]['file'].should  == 'c.rb'
+    decoded[3]['level'].should == 'info'
+  end
+end

data/spec/ruby-lint/presenter/text.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::Presenter::Text do
+  should 'format a set of entries' do
+    report    = RubyLint::Report.new
+    presenter = RubyLint::Presenter::Text.new
+
+    report.error('error message', 1, 1, 'a.rb')
+    report.error('error message 2', 2, 1, 'a.rb')
+    report.warning('warning message', 1, 1, 'b.rb')
+    report.info('info message', 1, 1, 'c.rb')
+
+    output = presenter.present(report)
+
+    output.should == <<-EOF.strip
+a.rb: error: line 1, column 1: error message
+a.rb: error: line 2, column 1: error message 2
+b.rb: warning: line 1, column 1: warning message
+c.rb: info: line 1, column 1: info message
+    EOF
+  end
+end