ruby-lint 1.0.3 → 1.1.0

data/spec/ruby-lint/variable_predicates_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe RubyLint::VariablePredicates do
+  before :all do
+    @array = s(:array)
+    @hash  = s(:hash)
+    @const = s(:const, nil, :A)
+    @path  = s(:const, s(:const, nil, :A), :B)
+  end
+
+  example 'check if an object is an array' do
+    @array.array?.should == true
+  end
+
+  example 'check if an object is a hash' do
+    @hash.hash?.should == true
+  end
+
+  example 'check if an object is a constant' do
+    @const.constant?.should == true
+  end
+
+  example 'check if an object is a constant path' do
+    @path.constant_path?.should == true
+  end
+
+  example 'return the Ruby class of an object' do
+    @array.ruby_class.should == 'Array'
+  end
+end

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

@@ -28,7 +28,7 @@ describe RubyLint::VirtualMachine do
       associations = build_associations('foo(:bar)')
       nodes        = associations.keys
 
-      nodes.length.should  == 1
+      nodes.length.should  == 2
       nodes[0].type.should == :root
     end
 
@@ -49,11 +49,13 @@ describe RubyLint::VirtualMachine do
       nodes        = associations.keys
       values       = associations.values
 
-      nodes.length.should  == 2
+      nodes.length.should  == 3
       nodes[0].type.should == :root
-      nodes[1].type.should == :send
+      nodes[1].type.should == :sym
+      nodes[2].type.should == :send
 
-      values[1].type.should == :unknown
+      values[1].type.should == :sym
+      values[2].type.should == :unknown
     end
   end
 end

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

@@ -1,30 +1,17 @@
 require 'spec_helper'
 
 describe RubyLint::VirtualMachine do
-  after do
-    RubyLint::GlobalScope.definitions.definitions[:const].delete('ERB')
-  end
-
   example 'automatically load constants' do
     definitions = build_definitions('ERB')
 
     definitions.lookup(:const, 'ERB').is_a?(ruby_object).should == true
-
-    RubyLint::GlobalScope.definitions.lookup(:const, 'ERB') \
-      .is_a?(ruby_object) \
-      .should == true
   end
 
   example 'automatically load constant paths' do
-    definitions = build_definitions('Enumerable::Enumerator')
-
-    definitions.lookup(:const, 'Enumerable') \
-      .lookup(:const, 'Enumerator') \
-      .is_a?(ruby_object) \
-      .should == true
+    definitions = build_definitions('Encoding::BINARY')
 
-    RubyLint::GlobalScope.definitions.lookup(:const, 'Enumerable') \
-      .lookup(:const, 'Enumerator') \
+    definitions.lookup(:const, 'Encoding') \
+      .lookup(:const, 'BINARY') \
       .is_a?(ruby_object) \
       .should == true
   end

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

@@ -20,5 +20,32 @@ end
         .is_a?(ruby_method) \
         .should == true
     end
+
+    context 'updating built-in definitions' do
+      before :all do
+        code = <<-CODE
+class Integer < Numeric
+  def foobar
   end
-end
+end
+        CODE
+
+        defs     = build_definitions(code)
+        @integer = defs.lookup(:const, 'Integer')
+        @fixnum  = defs.lookup(:const, 'Fixnum')
+      end
+
+      example 'include newly defined methods' do
+        @integer.has_definition?(:instance_method, 'foobar').should == true
+      end
+
+      example 'include existing methods' do
+        @integer.has_definition?(:instance_method, '%').should == true
+      end
+
+      example 'update definitions that point to the redefined definition' do
+        @fixnum.has_definition?(:instance_method, 'foobar').should == true
+      end
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/complex/rails_spec.rb

@@ -2,17 +2,20 @@ require 'spec_helper'
 
 describe RubyLint::VirtualMachine do
   describe 'rails' do
-    example 'process a basic Rails controller' do
-      code = fixture('complex/rails/basic_controller.rb')
-      defs = build_definitions(code)
-
-      controller = defs.lookup(:const, 'ApplicationController')
+    before :all do
+      code        = fixture('complex/rails/basic_controller.rb')
+      @defs       = build_definitions(code)
+      @controller = @defs.lookup(:const, 'ApplicationController')
+    end
 
-      controller.is_a?(ruby_object).should == true
+    example 'inherit the parent controller' do
+      @controller.has_definition?(:instance_method, 'login_required')
+        .should == true
+    end
 
-      controller.lookup(:instance_method, 'login_required') \
-        .is_a?(ruby_method) \
+    example 'include built-in Rails definitions' do
+      @controller.has_definition?(:method, 'allow_forgery_protection')
         .should == true
     end
   end
-end
+end

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

@@ -2,11 +2,14 @@ require 'spec_helper'
 
 describe RubyLint::VirtualMachine do
   describe 'global variables' do
-    example 'provide a list of default global variables' do
-      scope = RubyLint::GlobalScope.definitions
+    before :all do
+      @vm   = RubyLint::VirtualMachine.new
+      @defs = @vm.definitions
+    end
 
-      scope.lookup(:gvar, '$LOAD_PATH').is_a?(ruby_object).should == true
-      scope.lookup(:gvar, '$9').is_a?(ruby_object).should         == true
+    example 'provide a list of default global variables' do
+      @defs.lookup(:gvar, '$LOAD_PATH').is_a?(ruby_object).should == true
+      @defs.lookup(:gvar, '$9').is_a?(ruby_object).should         == true
     end
   end
-end
+end

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

@@ -53,12 +53,5 @@ end
       @first.callers[0].definition.should  == @third
       @second.callers[0].definition.should == @third
     end
-
-    example 'should not modify read-only definitions' do
-      method = @string.lookup(:method, 'new')
-
-      @third.calls[2].definition.should == method
-      method.callers.empty?.should      == true
-    end
   end
 end

data/spec/ruby-lint/virtual_machine/methods/attr_spec.rb

@@ -113,4 +113,70 @@ end
         .should == true
     end
   end
+
+  context 'attr methods and argument amounts' do
+    example 'set the arguments for attr' do
+      code = <<-CODE
+class Example
+  attr :foo
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Example')
+        .lookup(:instance_method, 'foo')
+        .arguments
+        .empty?
+        .should == true
+    end
+
+    example 'set the arguments for attr_reader' do
+      code = <<-CODE
+class Example
+  attr_reader :foo
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Example')
+        .lookup(:instance_method, 'foo')
+        .arguments
+        .empty?
+        .should == true
+    end
+
+    example 'set the arguments for attr_writer' do
+      code = <<-CODE
+class Example
+  attr_writer :foo
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Example')
+        .lookup(:instance_method, 'foo=')
+        .arguments
+        .length
+        .should == 1
+    end
+
+    example 'set the arguments for attr_accessor' do
+      code = <<-CODE
+class Example
+  attr_accessor :foo
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'Example')
+        .lookup(:instance_method, 'foo=')
+        .arguments
+        .length
+        .should == 1
+    end
+  end
 end

data/spec/ruby-lint/virtual_machine/methods/calls_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RubyLint::VirtualMachine do
+  context 'evaluating method calls' do
+    before :all do
+      code = <<-EOF
+# @return [String]
+def example
+  return 'foo'
+end
+
+variable = example
+      EOF
+
+      @defs = build_definitions(code)
+    end
+
+    example 'assign the correct return value to a local variable' do
+      value = @defs.lookup(:lvar, 'variable').value
+
+      value.type.should == :const
+      value.name.should == 'String'
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/methods/define_method_spec.rb

@@ -10,7 +10,7 @@ class A
 end
       CODE
 
-      assoc = build_associations(code).to_a.last.last
+      assoc = build_associations(code).to_a[-2].last
 
       assoc.type.should          == :block
       assoc.instance_type.should == :instance

data/spec/ruby-lint/virtual_machine/methods/docstrings_spec.rb

@@ -12,9 +12,10 @@ end
       defs = build_definitions(code)
 
       number  = defs.lookup(:instance_method, 'example').lookup(:lvar, 'number')
-      numeric = RubyLint::GlobalScope.global_constant('Numeric')
+      numeric = defs.lookup(:const, 'Numeric')
 
       number.is_a?(ruby_object).should        == true
+      numeric.is_a?(ruby_object).should       == true
       number.parents.include?(numeric).should == true
     end
 
@@ -39,10 +40,10 @@ def example(number)
 end
       CODE
 
-      float  = RubyLint::GlobalScope.global_constant('Float')
-      fixnum = RubyLint::GlobalScope.global_constant('Fixnum')
-
       defs   = build_definitions(code)
+      float  = defs.lookup(:const, 'Float')
+      fixnum = defs.lookup(:const, 'Fixnum')
+
       number = defs.lookup(:instance_method, 'example').lookup(:lvar, 'number')
 
       number.is_a?(ruby_object).should       == true
@@ -52,18 +53,28 @@ end
   end
 
   context 'method return values and docstrings' do
-    example 'extract the type of a return tag' do
+    before :all do
       code = <<-CODE
 # @return [Numeric]
 def example
 end
       CODE
 
-      defs    = build_definitions(code)
-      method  = defs.lookup(:instance_method, 'example')
-      numeric = RubyLint::GlobalScope.global_constant('Numeric')
+      @defs = build_definitions(code)
+    end
+
+    example 'extract the type of a return tag' do
+      method  = @defs.lookup(:instance_method, 'example')
+      numeric = @defs.lookup(:const, 'Numeric')
+
+      method.return_value.type.should == :const
+      method.return_value.name.should == 'Numeric'
+    end
+
+    example 'return values as instances' do
+      method = @defs.lookup(:instance_method, 'example')
 
-      method.return_value.should == numeric
+      method.return_value.instance?.should == true
     end
   end
 end

data/spec/ruby-lint/virtual_machine/methods/kernel_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RubyLint::VirtualMachine do
+  describe 'updating the Kernel module' do
+    before :all do
+      code = <<-CODE
+module Kernel
+  def foobar
+  end
+end
+      CODE
+
+      @definitions = build_definitions(code)
+      @kernel      = @definitions.lookup(:const, 'Kernel')
+    end
+
+    example 'add the method to the Kernel module' do
+      @kernel.has_definition?(:instance_method, 'foobar').should == true
+    end
+
+    example 'add the method to the global scope' do
+      @definitions.has_definition?(:instance_method, 'foobar').should == true
+    end
+  end
+end

data/spec/ruby-lint/virtual_machine/methods/patching_spec.rb

@@ -2,12 +2,6 @@ require 'spec_helper'
 
 describe RubyLint::VirtualMachine do
   describe 'patching methods' do
-    after do
-      RubyLint::GlobalScope.definitions.lookup(:const, 'String') \
-        .definitions[:method] \
-        .delete('foobar')
-    end
-
     example 'add a class method to the String class' do
       code = <<-CODE
 class String

data/spec/ruby-lint/virtual_machine/methods/square_bracket_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RubyLint::VirtualMachine do
+  # https://github.com/YorickPeterse/ruby-lint/issues/80
+  context 'defining square bracket methods' do
+    before :all do
+      code = <<-CODE
+class Example
+  def [](key)
+  end
+
+  def []=(key, value)
+  end
+end
+      CODE
+
+      @definitions = build_definitions(code)
+    end
+
+    example 'define the [] method' do
+      @definitions.lookup(:const, 'Example')
+        .has_definition?(:instance_method, '[]')
+        .should == true
+    end
+
+    example 'define the []= method' do
+      @definitions.lookup(:const, 'Example')
+        .has_definition?(:instance_method, '[]=')
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe RubyLint::VirtualMachine do
+  describe 'self in instances/classes' do
+    before :all do
+      code = <<-CODE
+class Example
+  def self.class_method
+    @class_self = self
+  end
+
+  def instance_method
+    @instance_self = self
+  end
+end
+      CODE
+
+      definitions = build_definitions(code)
+      @constant   = definitions.lookup(:const, 'Example')
+    end
+
+    example 'set the right instance type' do
+      @constant.lookup(:ivar, '@class_self').value.instance?.should    == false
+      @constant.lookup(:ivar, '@instance_self').value.instance?.should == true
+    end
+
+    example 'self should be defined as a class method' do
+      @constant.lookup(:method, 'self').is_a?(ruby_method).should == true
+    end
+
+    example 'self should be defined as an instance method' do
+      @constant.lookup(:instance_method, 'self')
+        .is_a?(ruby_method)
+        .should == true
+    end
+  end
+end