ruby-lint 1.1.0 → 2.0.0

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

@@ -1,182 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  context 'attr methods' do
-    example 'should define a read-only attribute using #attr' do
-      code = <<-CODE
-class Example
-  attr :number
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:ivar, '@number')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .lookup(:ivar, '@number')
-        .used?
-        .should == true
-    end
-
-    example 'should define an accessor attribute using #attr' do
-      code = <<-CODE
-class Example
-  attr :number, true
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number=')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:ivar, '@number')
-        .should == true
-    end
-
-    example 'should define a read-only attribute using #attr_reader' do
-      code = <<-CODE
-class Example
-  attr_reader :number
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number=')
-        .should == false
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:ivar, '@number')
-        .should == true
-    end
-
-    example 'should define a write-only attribute using #attr_writer' do
-      code = <<-CODE
-class Example
-  attr_writer :number
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number')
-        .should == false
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number=')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:ivar, '@number')
-        .should == true
-    end
-
-    example 'should define an accessor attribute using #attr_accessor' do
-      code = <<-CODE
-class Example
-  attr_accessor :number
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:instance_method, 'number=')
-        .should == true
-
-      defs.lookup(:const, 'Example')
-        .has_definition?(:ivar, '@number')
-        .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

@@ -1,25 +0,0 @@
-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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  context 'define_method' do
-    example 'change the instance type of the block to `:instance`' do
-      code = <<-CODE
-class A
-  define_method(:example) do
-  end
-end
-      CODE
-
-      assoc = build_associations(code).to_a[-2].last
-
-      assoc.type.should          == :block
-      assoc.instance_type.should == :instance
-    end
-
-    example 'should not mess up nested blocks' do
-      code = <<-CODE
-class A
-  something.each do
-    define_method(:example) do
-    end
-  end
-end
-      CODE
-
-      assoc = build_associations(code).to_a
-
-      something = assoc[2].last
-      define    = assoc[4].last
-
-      something.type.should          == :block
-      something.instance_type.should == :class
-
-      define.type.should          == :block
-      define.instance_type.should == :instance
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  describe 'defining methods' do
-    example '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
-
-    example '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/docstrings_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  context 'method arguments and docstrings' do
-    example 'extract the type of a parameter' do
-      code = <<-CODE
-# @param [Numeric] number
-def example(number)
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      number  = defs.lookup(:instance_method, 'example').lookup(:lvar, 'number')
-      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
-
-    example 'extract the type of a parameter using a method' do
-      code = <<-CODE
-# @param [#to_s] number
-def example(number)
-end
-      CODE
-
-      defs   = build_definitions(code)
-      number = defs.lookup(:instance_method, 'example').lookup(:lvar, 'number')
-
-      number.is_a?(ruby_object).should                                  == true
-      number.lookup(:instance_method, 'to_s').is_a?(ruby_method).should == true
-    end
-
-    example 'extract multiple types from a parameter' do
-      code = <<-CODE
-# @param [Float|Fixnum] number
-def example(number)
-end
-      CODE
-
-      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
-      number.parents.include?(float).should  == true
-      number.parents.include?(fixnum).should == true
-    end
-  end
-
-  context 'method return values and docstrings' do
-    before :all do
-      code = <<-CODE
-# @return [Numeric]
-def example
-end
-      CODE
-
-      @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.instance?.should == true
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  describe 'exporting variables out of method scopes' do
-    example '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/kernel_spec.rb

@@ -1,25 +0,0 @@
-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/parameters_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  describe 'creating variables for method parameters' do
-    example '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
-
-    example '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
-
-    example '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
-
-    example '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
-
-    # Keyword arguments were introduced in Ruby 2.0.
-    specific_ruby_version '2.0' do
-      example 'support keyword arguments' do
-        code   = 'def example(number: 10); end'
-        defs   = build_definitions(code)
-        method = defs.lookup(:instance_method, 'example')
-
-        method.lookup(:kwoptarg, 'number').value.value.should == 10
-        method.lookup(:lvar, 'number').value.value.should     == 10
-      end
-    end
-  end
-end