ruby-lint 0.0.3 → 0.0.4

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

@@ -0,0 +1,60 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'scoping class definitions' do
+    should 'process a global class' do
+      defs    = build_definitions('class Example; end')
+      example = defs.lookup(:const, 'Example')
+
+      example.is_a?(ruby_object).should == true
+
+      example.type.should == :const
+      example.name.should == 'Example'
+    end
+
+    should 'process a nested class' do
+      code = <<-CODE
+class First
+  class Second
+  end
+end
+      CODE
+
+      defs  = build_definitions(code)
+      first = defs.lookup(:const, 'First')
+
+      first.is_a?(ruby_object).should == true
+
+      defs.lookup(:const, 'Second').nil?.should == true
+
+      first.lookup(:const, 'Second') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'process a global and nested class' do
+      code = <<-CODE
+class First
+  class Second
+  end
+end
+
+class Third
+end
+      CODE
+
+      defs  = build_definitions(code)
+      first = defs.lookup(:const, 'First')
+
+      first.lookup(:const, 'Second').is_a?(ruby_object).should == true
+      first.lookup(:const, 'Third').is_a?(ruby_object).should == true
+
+      first.lookup(:const, 'Second') \
+        .lookup(:const, 'Third') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      defs.lookup(:const, 'Third').is_a?(ruby_object).should == true
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'rails' do
+    should 'process a basic Rails controller' do
+      code = fixture('complex/rails/basic_controller.rb')
+      defs = build_definitions(code)
+
+      controller = defs.lookup(:const, 'ApplicationController')
+
+      controller.is_a?(ruby_object).should == true
+
+      controller.lookup(:instance_method, 'login_required') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  # https://github.com/farrel/RCAP/blob/master/lib/rcap/cap_1_2/alert.rb
+  describe 'rcap' do
+    should 'process the Alert class' do
+      code  = fixture('complex/rcap.rb')
+      defs  = build_definitions(code)
+      const = defs.lookup_constant_path('RCAP::CAP_1_2::Alert')
+
+      const.lookup(:const, 'CAP_VERSION').value.value.should  == '1.2'
+      const.has_definition?(:instance_method, 'xmlns').should == true
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'slop' do
+    should 'process the Slop gem' do
+      code  = fixture('complex/slop.rb')
+      defs  = build_definitions(code)
+      const = defs.lookup(:const, 'Slop')
+
+      const.lookup(:const, 'VERSION').value.value.should == '3.4.5'
+
+      const.has_definition?(:method, 'parse').should  == true
+      const.has_definition?(:method, 'parse!').should == true
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ end
 
     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
+    defs.lookup(:lvar, 'key').is_a?(ruby_object).should   == true
+    defs.lookup(:lvar, 'value').is_a?(ruby_object).should == true
   end
 end

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

@@ -0,0 +1,13 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  should 'freeze the VM and all instance variables' do
+    vm = RubyLint::VirtualMachine.new
+
+    vm.freeze
+
+    vm.frozen?.should              == true
+    vm.definitions.frozen?.should  == true
+    vm.associations.frozen?.should == true
+  end
+end

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

@@ -0,0 +1,12 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'string interpolation' do
+    should 'process an assignment in a string' do
+      code = '"hello #{number = 10}"'
+      defs = build_definitions(code)
+
+      defs.lookup(:lvar, 'number').value.value.should == 10
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'defining methods' do
+    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(:lvar, 'number') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      defs.lookup(:lvar, '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(:const, '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
+  end
+end

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

@@ -0,0 +1,19 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'exporting variables out of method scopes' do
+    should 'export variables to the outer scope' do
+      code = <<-CODE
+def example
+  @number = 10
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:ivar, '@number') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  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(:lvar, '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(:lvar, 'other_number') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+
+    should 'take all argument types into account' do
+      code = <<-CODE
+def example(required, optional = 10, *splat, more, &block)
+  _required = required
+  _optional = optional
+  _splat    = splat
+  _more     = more
+  _block    = block
+end
+      CODE
+
+      defs   = build_definitions(code)
+      method = defs.lookup(:instance_method, 'example')
+
+      %w{_required _splat _more _block}.each do |name|
+        method.lookup(:lvar, name).is_a?(ruby_object).should == true
+      end
+
+      method.lookup(:lvar, '_optional').value.value.should == 10
+    end
+
+    should 'store arguments under special types' do
+      code = <<-CODE
+def example(required, optional = 10, *splat, more, &block)
+end
+      CODE
+
+      defs   = build_definitions(code)
+      method = defs.lookup(:instance_method, 'example')
+      types  = [
+        [:arg, 'required'],
+        [:optarg, 'optional'],
+        [:restarg, 'splat'],
+        [:arg, 'more'],
+        [:blockarg, 'block']
+      ]
+
+      types.each do |(type, name)|
+        method.lookup(type, name).is_a?(ruby_object).should == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  should 'be able to patch global definitions' do
+    after do
+      RubyLint::VirtualMachine.global_scope.lookup(:const, 'String') \
+        .definitions[:method] \
+        .delete('foobar')
+    end
+
+    should 'add a class method to the String class' do
+      code = <<-CODE
+class String
+  def self.foobar
+  end
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:const, 'String') \
+        .has_definition?(:method, 'foobar') \
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine 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 == :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
+end

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

@@ -0,0 +1,64 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe RubyLint::VirtualMachine do
+  describe 'method visibility' do
+    should 'define a method as public' do
+      code = <<-CODE
+def example
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_method, 'example').visibility.should == :public
+    end
+
+    should 'define a method as private' do
+      code = <<-CODE
+private
+
+def example
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_method, 'example').visibility.should == :private
+    end
+
+    should 'define a method as protected' do
+      code = <<-CODE
+protected
+
+def example
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_method, 'example').visibility.should == :protected
+    end
+
+    should 'define a method as private and then reset it' do
+      code = <<-CODE
+private
+
+def example
+end
+
+public
+
+def example_public
+end
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:instance_method, 'example').visibility.should == :private
+
+      defs.lookup(:instance_method, 'example_public') \
+        .visibility \
+        .should == :public
+    end
+  end
+end