ruby-lint 1.1.0 → 2.0.0

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe 'Using return values in assignments' do
-  example 'assign a return value' do
-    code  = 'word = String.new'
-    defs  = build_definitions(code)
-    value = defs.lookup(:lvar, 'word').value
-
-    value.is_a?(ruby_object).should == true
-
-    value.type.should      == :const
-    value.name.should      == 'String'
-    value.instance?.should == true
-  end
-
-  example 'assign a nil value for a missing return value' do
-    code = <<-CODE
-def example
-end
-
-number = example
-    CODE
-
-    defs = build_definitions(code)
-
-    defs.lookup(:lvar, 'number').value.type.should == :unknown
-  end
-
-  example 'assign return values when chaining method calls' do
-    code  = 'word = String.new.initialize.initialize'
-    defs  = build_definitions(code)
-    value = defs.lookup(:lvar, 'word').value
-
-    value.is_a?(ruby_object).should == true
-
-    value.type.should      == :const
-    value.name.should      == 'String'
-    value.instance?.should == true
-  end
-
-  describe 'setting instance types for core Ruby types' do
-    example 'create a new String instance' do
-      defs = build_definitions('number = "10"')
-
-      defs.lookup(:lvar, 'number').value.instance?.should == true
-    end
-
-    example 'create a new Symbol instance' do
-      defs = build_definitions('number = :"10"')
-
-      defs.lookup(:lvar, 'number').value.instance?.should == true
-    end
-
-    example 'create a new Fixnum instance' do
-      defs = build_definitions('number = 10')
-
-      defs.lookup(:lvar, 'number').value.instance?.should == true
-    end
-
-    example 'create a new Float instance' do
-      defs = build_definitions('number = 10.0')
-
-      defs.lookup(:lvar, 'number').value.instance?.should == true
-    end
-
-    example 'create a new Array instance' do
-      defs = build_definitions('number = [10]')
-
-      defs.lookup(:lvar, 'number').value.instance?.should == true
-    end
-
-    example 'create a new Hash instance' do
-      defs = build_definitions('number = {:a => 10}')
-
-      defs.lookup(:lvar, 'number').value.instance?.should == true
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  context 'variable assignments' do
-    example '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
-
-    example '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
-
-    example 'assign a value to a constant path' do
-      defs = build_definitions('module Foo; end; Foo::FOO = 10')
-      foo  = defs.lookup(:const, 'Foo').lookup(:const, 'FOO')
-
-      foo.is_a?(ruby_object).should == true
-
-      foo.name.should        == 'FOO'
-      foo.value.value.should == 10
-    end
-
-    example '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
-
-    example '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
-
-    example 'assign nil to a value' do
-      defs  = build_definitions('variable = nil')
-      value = defs.lookup(:lvar, 'variable').value
-
-      value.type.should            == :nil
-      value.parents[0].name.should == 'NilClass'
-    end
-
-    example 'assign true to a value' do
-      defs  = build_definitions('variable = true')
-      value = defs.lookup(:lvar, 'variable').value
-
-      value.type.should            == :true
-      value.parents[0].name.should == 'TrueClass'
-    end
-
-    example 'assign false to a value' do
-      defs  = build_definitions('variable = false')
-      value = defs.lookup(:lvar, 'variable').value
-
-      value.type.should            == :false
-      value.parents[0].name.should == 'FalseClass'
-    end
-
-    example 'assigning a magic global variable to a variable' do
-      defs  = build_definitions('variable = $1')
-      value = defs.lookup(:lvar, 'variable').value
-
-      value.type.should == :unknown
-    end
-
-    example 'global variables should be assigned in the global scope' do
-      code = <<-CODE
-class Foo
-  def foo
-    $bar = 10
-  end
-end
-      CODE
-
-      defs = build_definitions(code)
-
-      defs.lookup(:gvar, '$bar').value.value.should == 10
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  example '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
-
-  describe 'method calls' do
-    example 'should not add associations' do
-      associations = build_associations('foo')
-      nodes        = associations.keys
-
-      nodes.length.should  == 1
-      nodes[0].type.should == :root
-    end
-
-    example 'should not add associations for methods with arguments' do
-      associations = build_associations('foo(:bar)')
-      nodes        = associations.keys
-
-      nodes.length.should  == 2
-      nodes[0].type.should == :root
-    end
-
-    example 'should not add associations for methods called on methods' do
-      associations = build_associations('foo.bar')
-      nodes        = associations.keys
-      values       = associations.values
-
-      nodes.length.should  == 2
-      nodes[0].type.should == :root
-      nodes[1].type.should == :send
-
-      values[1].type.should == :unknown
-    end
-
-    example 'should not add associations for stacked methods with arguments' do
-      associations = build_associations('foo.bar(:baz)')
-      nodes        = associations.keys
-      values       = associations.values
-
-      nodes.length.should  == 3
-      nodes[0].type.should == :root
-      nodes[1].type.should == :sym
-      nodes[2].type.should == :send
-
-      values[1].type.should == :sym
-      values[2].type.should == :unknown
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  example 'automatically load constants' do
-    definitions = build_definitions('ERB')
-
-    definitions.lookup(:const, 'ERB').is_a?(ruby_object).should == true
-  end
-
-  example 'automatically load constant paths' do
-    definitions = build_definitions('Encoding::BINARY')
-
-    definitions.lookup(:const, 'Encoding') \
-      .lookup(:const, 'BINARY') \
-      .is_a?(ruby_object) \
-      .should == true
-  end
-end

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

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  example '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
-
-  example '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
-
-  example 'blocks should be instances by default' do
-    code = <<-CODE
-example do
-end
-    CODE
-
-    block = build_associations(code).to_a.last.last
-
-    block.type.should          == :block
-    block.instance_type.should == :instance
-  end
-
-  example 'blocks should inherit the instance type from the outer scope' do
-    code = <<-CODE
-class A
-  example do
-  end
-end
-    CODE
-
-    block = build_associations(code).to_a.last.last
-
-    block.type.should          == :block
-    block.instance_type.should == :class
-  end
-
-  example '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_spec.rb

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

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::VirtualMachine do
-  describe 'extending classes' do
-    example '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
-
-    example '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
-
-    example '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
-
-    example '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
-
-    # This is to ensure that ruby-lint doesn't blow itself up when trying to
-    # use a constant as a parent class that can't be found (e.g. a user defined
-    # class).
-    #
-    # See https://github.com/YorickPeterse/ruby-lint/issues/32 for the
-    # motivation behind this fix/test.
-    example 'inherit Object as a fallback when the parent can not be found' do
-      code = <<-CODE
-class Foo < Bar
-end
-      CODE
-
-      defs    = build_definitions(code)
-      parents = defs.lookup(:const, 'Foo').parents
-
-      parents.length.should == 2
-
-      parents.include?(defs.lookup(:const, 'Object')).should == true
-    end
-
-    example '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