ruby-lint 0.0.3 → 0.0.4

data/spec/ruby-lint/{definitions_builder → virtual_machine}/assignments/return_values.rb

@@ -4,11 +4,11 @@ describe 'Using return values in assignments' do
   it 'should assign a return value' do
     code  = 'word = String.new'
     defs  = build_definitions(code)
-    value = defs.lookup(:local_variable, 'word').value
+    value = defs.lookup(:lvar, 'word').value
 
     value.is_a?(ruby_object).should == true
 
-    value.type.should      == :constant
+    value.type.should      == :const
     value.name.should      == 'String'
     value.instance?.should == true
   end
@@ -23,17 +23,17 @@ number = example
 
     defs = build_definitions(code)
 
-    defs.lookup(:local_variable, 'number').value.nil?.should == true
+    defs.lookup(:lvar, 'number').value.nil?.should == true
   end
 
   it 'should assign return values when chaining method calls' do
     code  = 'word = String.new.initialize.initialize'
     defs  = build_definitions(code)
-    value = defs.lookup(:local_variable, 'word').value
+    value = defs.lookup(:lvar, 'word').value
 
     value.is_a?(ruby_object).should == true
 
-    value.type.should      == :constant
+    value.type.should      == :const
     value.name.should      == 'String'
     value.instance?.should == true
   end
@@ -42,37 +42,37 @@ number = example
     should 'create a new String instance' do
       defs = build_definitions('number = "10"')
 
-      defs.lookup(:local_variable, 'number').value.instance?.should == true
+      defs.lookup(:lvar, 'number').value.instance?.should == true
     end
 
     should 'create a new Symbol instance' do
       defs = build_definitions('number = :"10"')
 
-      defs.lookup(:local_variable, 'number').value.instance?.should == true
+      defs.lookup(:lvar, 'number').value.instance?.should == true
     end
 
     should 'create a new Fixnum instance' do
       defs = build_definitions('number = 10')
 
-      defs.lookup(:local_variable, 'number').value.instance?.should == true
+      defs.lookup(:lvar, 'number').value.instance?.should == true
     end
 
     should 'create a new Float instance' do
       defs = build_definitions('number = 10.0')
 
-      defs.lookup(:local_variable, 'number').value.instance?.should == true
+      defs.lookup(:lvar, 'number').value.instance?.should == true
     end
 
     should 'create a new Array instance' do
       defs = build_definitions('number = [10]')
 
-      defs.lookup(:local_variable, 'number').value.instance?.should == true
+      defs.lookup(:lvar, 'number').value.instance?.should == true
     end
 
     should 'create a new Hash instance' do
       defs = build_definitions('number = {:a => 10}')
 
-      defs.lookup(:local_variable, 'number').value.instance?.should == true
+      defs.lookup(:lvar, 'number').value.instance?.should == true
     end
   end
 end

data/spec/ruby-lint/virtual_machine/assignments/variables.rb

@@ -0,0 +1,85 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'variable assignments' do
+    should 'assign different types of variables' do
+      types = {
+        'number'   => :lvar,
+        '@number'  => :ivar,
+        '@@number' => :cvar,
+        '$number'  => :gvar,
+        'NUMBER'   => :const
+      }
+
+      types.each do |name, type|
+        number = build_definitions("#{name} = 10").lookup(type, name)
+
+        number.name.should        == name
+        number.value.value.should == 10
+      end
+    end
+
+    should 'assign multiple values to multiple variables' do
+      defs    = build_definitions('number, numberx = 10, 20')
+      number  = defs.lookup(:lvar, 'number')
+      numberx = defs.lookup(:lvar, 'numberx')
+
+      number.is_a?(ruby_object).should == true
+
+      number.name.should        == 'number'
+      number.value.value.should == 10
+
+      numberx.is_a?(ruby_object).should == true
+
+      numberx.name.should        == 'numberx'
+      numberx.value.value.should == 20
+    end
+
+    should 'assign a value to a constant path' do
+      defs = build_definitions('Kernel::FOO = 10')
+      foo  = defs.lookup(:const, 'Kernel').lookup(:const, 'FOO')
+
+      foo.is_a?(ruby_object).should == true
+
+      foo.name.should        == 'FOO'
+      foo.value.value.should == 10
+    end
+
+    should 'assign a single value to multiple variables' do
+      code = 'first = second = third = 10'
+      defs = build_definitions(code)
+
+      %w{first second third}.each do |name|
+        variable = defs.lookup(:lvar, name)
+
+        variable.is_a?(ruby_object).should == true
+
+        variable.value.type.should  == :int
+        variable.value.value.should == 10
+      end
+    end
+
+    should 'resolve variables in assignments' do
+      code = <<-CODE
+a = 1
+b = a
+
+foo = 100 # to ensure this code doesn't use the last assigned values.
+
+c = b
+d = c
+      CODE
+
+      defs = build_definitions(code)
+
+      %w{a b c d}.each do |name|
+        var = defs.lookup(:lvar, name)
+
+        var.value.type.should  == :int
+        var.value.value.should == 1
+      end
+
+      defs.lookup(:lvar, 'foo').value.value.should == 100
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/associate_nodes.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  should 'associate AST nodes and their definitions' do
+    tokens = parse('def foobar; end', false)
+    vm     = RubyLint::VirtualMachine.new
+
+    vm.iterate(tokens)
+
+    defs   = vm.definitions
+    assoc  = vm.associations
+    method = tokens.children[0]
+
+    assoc.key?(method).should == true
+    assoc[method].should      == defs.lookup(:instance_method, 'foobar')
+  end
+end

data/spec/ruby-lint/virtual_machine/autoloading.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  after do
+    RubyLint::VirtualMachine.global_scope.definitions[:const].delete('ERB')
+  end
+
+  should 'automatically load constants' do
+    definitions = build_definitions('ERB')
+
+    definitions.lookup(:const, 'ERB').is_a?(ruby_object).should == true
+
+    RubyLint::VirtualMachine.global_scope.lookup(:const, 'ERB') \
+      .is_a?(ruby_object) \
+      .should == true
+  end
+
+  should 'automatically load constant paths' do
+    definitions = build_definitions('Enumerable::Enumerator')
+
+    definitions.lookup(:const, 'Enumerable') \
+      .lookup(:const, 'Enumerator') \
+      .is_a?(ruby_object) \
+      .should == true
+
+    RubyLint::VirtualMachine.global_scope.lookup(:const, 'Enumerable') \
+      .lookup(:const, 'Enumerator') \
+      .is_a?(ruby_object) \
+      .should == true
+  end
+end

data/spec/ruby-lint/virtual_machine/blocks.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  should 'make variables available in a block' do
+    code = <<-CODE
+number = 10
+
+example do
+end
+    CODE
+
+    definition = build_associations(code).to_a.last.last
+
+    number = definition.lookup(:lvar, 'number')
+
+    number.is_a?(ruby_object).should == true
+    number.value.value.should        == 10
+  end
+
+  should 'make block arguments available as variables inside the block only' do
+    code = <<-CODE
+example do
+  number = 10
+end
+    CODE
+
+    associations = build_associations(code).to_a
+
+    root_def  = associations.first.last
+    block_def = associations.last.last
+
+    root_def.lookup(:lvar, 'number').nil?.should         == true
+    block_def.lookup(:lvar, 'number').value.value.should == 10
+  end
+
+  should 'update outer variables modified in the block' do
+    code = <<-CODE
+number   = 10
+@number  = 10
+@@number = 10
+$number  = 10
+
+example do
+  number   = 20
+  @number  = 20
+  @@number = 20
+  $number  = 20
+end
+    CODE
+
+    defs = build_definitions(code)
+
+    variables = {
+      :lvar => 'number',
+      :ivar => '@number',
+      :cvar => '@@number',
+      :gvar => '$number'
+    }
+
+    variables.each do |type, name|
+      defs.lookup(type, name).value.value.should == 20
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/classes/class_methods.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'defining class methods' do
+    should 'define a single class method using `self`' do
+      code = <<-CODE
+class Example
+  def self.class_method
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Example') \
+        .lookup(:method, 'class_method') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/classes/extending.rb

@@ -0,0 +1,104 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'extending classes' do
+    should 'set the default parent class' do
+      defs = build_definitions('class First; end')
+
+      defs.lookup(:const, 'First') \
+        .lookup(:method, 'new') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'extend a class using a parent' do
+      code = <<-CODE
+class First
+  def example
+  end
+end
+
+class Second < First
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Second') \
+        .parents \
+        .map(&:name) \
+        .should == ['First', 'root']
+
+      defs.lookup(:const, 'Second') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'extend a class using a constant path as the parent class' do
+      code = <<-CODE
+class First
+  class Second
+    def example
+    end
+  end
+end
+
+class Third < First::Second
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Third') \
+        .parents \
+        .map(&:name) \
+        .should == ['Second', 'root']
+
+      defs.lookup(:const, 'Third') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'extend a class using a variable' do
+      code = <<-CODE
+parent = String
+
+class MyString < parent
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      parents = defs.lookup(:const, 'MyString').parents
+
+      parents.length.should                                  == 2
+      parents.include?(defs.lookup(:const, 'String')).should == true
+    end
+
+    # Ruby only allows classes to inherit from constants.
+    should 'not be able to inherit non constant values' do
+      code = <<-CODE
+class MyString < 'foo'
+
+end
+      CODE
+
+      error = should.raise?(TypeError) do
+        build_definitions(code)
+      end
+
+      error.message.should == 'classes can only inherit another class'
+    end
+
+    should 'inherit from Object when importing String' do
+      defs = build_definitions('String')
+
+      defs.lookup(:const, 'String') \
+        .lookup(:method, 'new') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/classes/redefining.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'redefining classes' do
+    should 'update a class when it is redefined' do
+      code = <<-CODE
+class First
+end
+
+class First
+  def example
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'First') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/classes/sclass.rb

@@ -0,0 +1,94 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'using sclass blocks' do
+    should 'define a class method using `class << self`' do
+      code = <<-CODE
+class First
+  class << self
+    def example
+    end
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'First') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'define a class method using `class << self` in the global scope' do
+      code = <<-CODE
+class << self
+  def example
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:method, 'example').is_a?(ruby_method).should == true
+    end
+
+    should 'define a class method using `class << String`' do
+      code = <<-CODE
+class << String
+  def example
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'String') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'define a class method using `class << String` nested in a class' do
+      code = <<-CODE
+class First
+  class << String
+    def example
+    end
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'First') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == false
+
+      defs.lookup(:const, 'String') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+
+    should 'define an instance method using `class << variable`' do
+      code = <<-CODE
+variable = "foo"
+
+class << variable
+  def example
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:lvar, 'variable') \
+        .value \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+end