ruby-lint 0.0.2 → 0.0.3

data/spec/ruby-lint/definitions_builder/for.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Building variable definitions using for loops' do
+  should 'create local variables' do
+    code = <<-CODE
+for key, value in something
+
+end
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:local_variable, 'key').is_a?(ruby_object).should   == true
+    defs.lookup(:local_variable, 'value').is_a?(ruby_object).should == true
+  end
+end

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

@@ -0,0 +1,147 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Building method definitions' do
+  describe 'scoping method definitions' do
+    should 'process a global method' do
+      defs    = build_definitions('def example; end')
+      example = defs.lookup(:instance_method, 'example')
+
+      example.is_a?(ruby_method).should == true
+
+      example.type.should        == :method_definition
+      example.method_type.should == :instance_method
+      example.name.should        == 'example'
+    end
+
+    should 'process a nested method' do
+      code = <<-CODE
+def first
+  def second
+  end
+end
+      CODE
+
+      defs  = build_definitions(code)
+      first = defs.lookup(:instance_method, 'first')
+
+      first.is_a?(ruby_method).should == true
+
+      first.lookup(:instance_method, 'second') \
+        .is_a?(ruby_method) \
+        .should == true
+
+      defs.lookup(:instance_method, 'second').nil?.should == true
+    end
+
+    should 'process a global and nested method' do
+      code = <<-CODE
+def first
+  def second
+  end
+end
+
+def third
+end
+      CODE
+
+      defs  = build_definitions(code)
+      first = defs.lookup(:instance_method, 'first')
+
+      first.lookup(:instance_method, 'second') \
+        .is_a?(ruby_method) \
+        .should == true
+
+      first.lookup(:instance_method, 'second') \
+        .lookup(:instance_method, 'third') \
+        .is_a?(ruby_method) \
+        .should == true
+
+      defs.lookup(:instance_method, 'third') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+
+  should 'process a definition with a variable assignment in the body' do
+    code = <<-CODE
+def example
+  number = 10
+end
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:instance_method, 'example') \
+      .lookup(:local_variable, 'number') \
+      .is_a?(ruby_object) \
+      .should == true
+
+    defs.lookup(:local_variable, 'number').nil?.should == true
+  end
+
+  should 'process a definition with a receiver' do
+    code = <<-CODE
+def String.example
+  number = 10
+end
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:constant, 'String') \
+      .lookup(:method, 'example') \
+      .is_a?(ruby_method) \
+      .should == true
+
+    defs.lookup(:method, 'example').nil?.should          == true
+    defs.lookup(:instance_method, 'example').nil?.should == true
+  end
+
+  describe 'creating variables for method parameters' do
+    should 'create local variables' do
+      code = <<-CODE
+def example(number)
+  return number
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_method, 'example') \
+        .lookup(:local_variable, 'number') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'allow the assignment using parameters' do
+      code = <<-CODE
+def example(number)
+  other_number = number
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_method, 'example') \
+        .lookup(:local_variable, 'other_number') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+
+  describe 'exporting variables' do
+    should 'export variables to the outer scope' do
+      code = <<-CODE
+def example
+  @number = 10
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_variable, '@number') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Building module definitions' do
+  describe 'scoping definitions' do
+    should 'process a global module' do
+      defs    = build_definitions('module Example; end')
+      example = defs.lookup(:constant, 'Example')
+
+      example.is_a?(ruby_object).should == true
+
+      example.type.should == :module
+      example.name.should == 'Example'
+    end
+
+    should 'process a nested module' do
+      code = <<-CODE
+module First
+  module Second
+  end
+end
+      CODE
+
+      defs  = build_definitions(code)
+      first = defs.lookup(:constant, 'First')
+
+      first.is_a?(ruby_object).should == true
+
+      defs.lookup(:constant, 'Second').nil?.should == true
+
+      first.lookup(:constant, 'Second') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'process a global and nested module' do
+      code = <<-CODE
+module First
+  module Second
+  end
+end
+
+module Third
+end
+      CODE
+
+      defs  = build_definitions(code)
+      first = defs.lookup(:constant, 'First')
+
+      first.lookup(:constant, 'Second') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      # Due to "First" and "Third" being defined in the same scope the "Third"
+      # constant is available inside the "First" module.
+      first.lookup(:constant, 'Third') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      first.lookup(:constant, 'Second') \
+        .lookup(:constant, 'Third') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      defs.lookup(:constant, 'Third') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+
+  describe 'redefining modules' do
+    should 'update a module when it is redefined' do
+      code = <<-CODE
+module First
+end
+
+module First
+  def example
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:constant, 'First') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+
+  describe 'including modules' do
+    should 'include a module' do
+      code = <<-CODE
+module First
+  def example
+  end
+end
+
+module Second
+  include First
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:constant, 'Second') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'extend a module' do
+      code = <<-CODE
+module First
+  def example
+  end
+end
+
+module Second
+  extend First
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:constant, 'Second') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'include a module using a constant path' do
+      code = <<-CODE
+module First
+  module Second
+    def example
+    end
+  end
+end
+
+module Third
+  include First::Second
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:constant, 'Third') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'include a module using a variable' do
+      code = <<-CODE
+module First
+  def example
+  end
+end
+
+module Second
+  first = First
+  include first
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:constant, 'Second') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+end

data/spec/ruby-lint/definitions_builder/reference_amount.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Count the reference amount of variables' do
+  should 'count the amount of references for a variable' do
+    code = <<-CODE
+number = 10
+number
+number
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:local_variable, 'number').reference_amount.should == 2
+  end
+
+  should 'count the amount of references for a constant path' do
+    code = <<-CODE
+module A; end
+A::B = 10
+A::B
+A::B
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:constant, 'A') \
+      .lookup(:constant, 'B') \
+      .reference_amount \
+      .should == 2
+  end
+end

data/spec/ruby-lint/definitions_builder/unused.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Marking variables as used/unused' do
+  should 'mark variables as unused by default' do
+    defs = build_definitions('number = 10')
+
+    defs.lookup(:local_variable, 'number').used?.should == false
+  end
+
+  should 'mark variables as used' do
+    defs = build_definitions('number = 10; number')
+
+    defs.lookup(:local_variable, 'number').used?.should == true
+  end
+end

data/spec/ruby-lint/extensions/string.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'RubyLint String extensions' do
+  should 'snake_case a String' do
+    'HelloWorld::Foo::Bar'.snake_case.should == 'hello_world_foo_bar'
+  end
+end

data/spec/ruby-lint/iterator.rb

@@ -1,452 +1,77 @@
 require File.expand_path('../../helper', __FILE__)
 
 describe 'RubyLint::Iterator' do
-  it 'Iterate over a simple AST' do
-    code = <<-CODE
-number = 10
-number
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :assigned
-      attr_reader :referenced
-
-      def on_assignment(token)
-        @assigned = true
-      end
-
-      def on_local_variable(token)
-        @referenced = true
-      end
-    end
-
-    iterator.bind(callback)
-
-    iterator.run(tokens)
-
-    iterator.callbacks[0].assigned.should   == true
-    iterator.callbacks[0].referenced.should == true
-  end
-
-  it 'Iterate over a multi dimensional AST' do
-    code = <<-CODE
-class Foo
-  def initialize
-    @number = 10
-  end
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :class_name
-      attr_reader :method_name
-      attr_reader :assigned
-
-      def on_class(token)
-        @class_name = token.name[0]
-      end
+  should 'iterate over a simple AST' do
+    ast = parse('10; 20; 30', false)
 
-      def on_method_definition(token)
-        @method_name = token.name
+    iterator = Class.new(RubyLint::Iterator) do
+      def on_root(node)
+        @options[:events] << :on_root
       end
 
-      def on_assignment(token)
-        @assigned = true
-      end
-    end
-
-    iterator.bind(callback)
-
-    iterator.run(tokens)
-
-    iterator.callbacks[0].class_name.should  == 'Foo'
-    iterator.callbacks[0].method_name.should == 'initialize'
-    iterator.callbacks[0].assigned.should    == true
-  end
-
-  it 'Call an event after iterating over a node' do
-    code = <<-CODE
-def some_method
-  return 10
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :before
-      attr_reader :after
-
-      def on_method_definition(token)
-        @before = token.name
-      end
-
-      def after_method_definition(token)
-        @after = token.name
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    iterator.callbacks[0].before.should == 'some_method'
-    iterator.callbacks[0].after.should  == 'some_method'
-  end
-
-  it 'Iterate over a begin/rescue statement' do
-    code = <<-CODE
-begin
-  raise
-rescue RuntimeError => e
-  puts 'runtime error!'
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :method_names
-      attr_reader :exception
-      attr_reader :exception_var
-
-      def initialize(*args)
-        super
-
-        @method_names = []
+      def after_root(node)
+        @options[:events] << :after_root
       end
 
-      def on_method(token)
-        @method_names << token.name
-      end
+      def on_integer(node)
+        unless @options[:events].include?(:on_integer)
+          @options[:events] << :on_integer
+        end
 
-      def on_constant(token)
-        @exception = token.name
+        @options[:numbers] << node.children[0]
       end
 
-      def on_identifier(token)
-        @exception_var = token.name
+      def after_integer(node)
+        unless @options[:events].include?(:after_integer)
+          @options[:events] << :after_integer
+        end
       end
     end
 
-    iterator.bind(callback)
-    iterator.run(tokens)
+    iterator = iterator.new(:numbers => [], :events => [])
 
-    obj = iterator.callbacks[0]
+    iterator.iterate(ast)
 
-    obj.method_names.should  == ['raise', 'puts']
-    obj.exception.should     == 'RuntimeError'
-    obj.exception_var.should == 'e'
+    iterator.options[:numbers].should == ['10', '20', '30']
+    iterator.options[:events].should  == [
+      :on_root,
+      :on_integer,
+      :after_integer,
+      :after_root
+    ]
   end
 
-  it 'Iterate over an if statement' do
+  should 'iterate over a multi dimensional AST' do
     code = <<-CODE
-a, b, c, d, e, f = [1, 2, 3, 4, 5, 6]
-
-if a == b
-  first
-elsif c == d
-  second
-elsif e == f
-  third
-else
-  fourth
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :variables
-      attr_reader :methods
-
-      def initialize(*args)
-        super
-
-        @variables = []
-        @methods   = []
-      end
-
-      def on_local_variable(token)
-        @variables << token.name
-      end
-
-      def on_method(token)
-        @methods << token.name
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    obj = iterator.callbacks[0]
-
-    obj.variables.should == %w{a b c d e f}
-    obj.methods.should   == %w{first second third fourth}
+class Example
+  def some_method
+    puts '10'
   end
-
-  it 'Iterate over a case statement' do
-    code = <<-CODE
-case number
-when 10
-  first
-when 20
-  second
-when 30
-  third
-else
-  fourth
 end
     CODE
 
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :methods
-      attr_reader :numbers
+    ast = parse(code, false)
 
-      def initialize(*args)
-        super
-
-        @methods = []
-        @numbers = []
+    iterator = Class.new(RubyLint::Iterator) do
+      def on_class(node)
+        @options[:class] = node.children[0].children[0]
       end
 
-      def on_method(token)
-        @methods << token.name
+      def on_method_definition(node)
+        @options[:method] = node.children[0]
       end
 
-      def on_integer(token)
-        @numbers << token.value
+      def on_method(node)
+        @options[:call] = node.children[0]
       end
     end
 
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    obj = iterator.callbacks[0]
-
-    obj.numbers.should == %w{10 20 30}
-    obj.methods.should == %w{number first second third fourth}
-  end
-
-  it 'Iterate over a for loop' do
-    code = <<-CODE
-for key, value in {:name => 'Ruby'}
-  puts key
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :symbol
-      attr_reader :string
-      attr_reader :names
-
-      def initialize(*args)
-        super
-
-        @names = []
-      end
-
-      def on_local_variable(token)
-        @names << token.name
-      end
-
-      def on_identifier(token)
-        @names << token.name
-      end
-
-      def on_symbol(token)
-        @symbol = token.name
-      end
-
-      def on_string(token)
-        @string = token.value
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    obj = iterator.callbacks[0]
-
-    obj.symbol.should == 'name'
-    obj.string.should == 'Ruby'
-    obj.names.should  == %w{key value key}
-  end
-
-  it 'Iterate over a while statement' do
-    code = <<-CODE
-while foo == 10
-  puts 20
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :numbers
-      attr_reader :methods
-
-      def initialize(*args)
-        super
-
-        @numbers = []
-        @methods = []
-      end
-
-      def on_identifier(token)
-        @methods << token.name
-      end
-
-      def on_method(token)
-        @methods << token.name
-      end
-
-      def on_integer(token)
-        @numbers << token.value
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    obj = iterator.callbacks[0]
-
-    obj.methods.should == %w{foo puts}
-    obj.numbers.should == %w{10 20}
-  end
-
-  it 'Iterate over a method definition' do
-    code = <<-CODE
-def foobar(required, optional = 10, *rest, more, &block)
-  return 20
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :variables
-      attr_reader :numbers
-
-      def initialize(*args)
-        super
-
-        @variables = []
-        @numbers   = []
-      end
-
-      def on_local_variable(token)
-        @variables << token.name
-      end
-
-      def on_integer(token)
-        @numbers << token.value
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    obj = iterator.callbacks[0]
-
-    obj.numbers.should   == %w{10 20}
-    obj.variables.should == %w{required optional rest more block}
-  end
-
-  it 'Iterate over a method call' do
-    tokens   = RubyLint::Parser.new('puts "Foo", "Bar"').parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :params
-
-      def initialize(*args)
-        @params = []
-      end
-
-      def on_string(token)
-        @params << token.value
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    obj = iterator.callbacks[0]
-
-    obj.params.should == %w{Foo Bar}
-  end
-
-  it 'Call an event before and after iterating over all nodes' do
-    code = <<-CODE
-class Person
-  def initialize
-    @name = 'Matz'
-  end
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-    callback = Class.new(RubyLint::Callback) do
-      attr_reader :start
-      attr_reader :finish
-
-      def initialize(*args)
-        super
-
-        @start  = 0
-        @finish = 0
-      end
-
-      def on_start
-        @start += 1
-      end
-
-      def on_finish
-        @finish += 1
-      end
-    end
-
-    iterator.bind(callback)
-    iterator.run(tokens)
-
-    iterator.callbacks[0].start.should  == 1
-    iterator.callbacks[0].finish.should == 1
-  end
-
-  it 'Share data between callback classes' do
-    code = <<-CODE
-def example_method
-  return 10
-end
-    CODE
-
-    tokens   = RubyLint::Parser.new(code).parse
-    iterator = RubyLint::Iterator.new
-
-    setter = Class.new(RubyLint::Callback) do
-      def on_method_definition(token)
-        @storage[:method_name] = token.name
-      end
-    end
-
-    getter = Class.new(RubyLint::Callback) do
-      attr_reader :storage
-    end
+    iterator = iterator.new
 
-    iterator.bind(setter)
-    iterator.bind(getter)
-    iterator.run(tokens)
+    iterator.iterate(ast)
 
-    iterator.callbacks[1].storage.class.should         == Hash
-    iterator.callbacks[1].storage[:method_name].should == 'example_method'
+    iterator.options[:class].should  == 'Example'
+    iterator.options[:method].should == 'some_method'
+    iterator.options[:call].should   == 'puts'
   end
 end