ruby-lint 0.0.2 → 0.0.3

data/spec/ruby-lint/definitions_builder/assignments/hashes.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Building variable definitions' do
+  should 'assign hashes as instances' do
+    defs  = build_definitions('numbers = {}')
+    value = defs.lookup(:local_variable, 'numbers').value
+
+    value.instance?.should == true
+
+    value.has_definition?(:instance_method, 'each').should == true
+  end
+
+  describe 'hash key assignments' do
+    should 'return key/value pairs as an Array' do
+      code    = 'numbers = {:key => "value", :extra => "example"}'
+      defs    = build_definitions(code)
+      numbers = defs.lookup(:local_variable, 'numbers')
+      value   = numbers.value
+
+      value.value.is_a?(Array).should == true
+      value.value.length.should       == 2
+
+      value.value[0].name.should        == 'key'
+      value.value[0].value.type.should  == :string
+      value.value[0].value.value.should == 'value'
+
+      value.value[1].name.should        == 'extra'
+      value.value[1].value.type.should  == :string
+      value.value[1].value.value.should == 'example'
+    end
+
+    should 'process a single key assignment' do
+      code = <<-CODE
+numbers        = {}
+numbers['one'] = 1
+      CODE
+
+      defs = build_definitions(code)
+
+      numbers = defs.lookup(:local_variable, 'numbers')
+      one     = numbers.lookup(:member, 'one')
+
+      one.is_a?(ruby_object).should == true
+      one.name.should               == 'one'
+      one.type.should               == :string
+
+      one.value.type.should  == :integer
+      one.value.value.should == '1'
+    end
+
+    should 'process a single key assignment using variables' do
+      code = <<-CODE
+key          = 'one'
+numbers      = {'two' => 2}
+numbers[key] = 1
+      CODE
+
+      defs    = build_definitions(code)
+      numbers = defs.lookup(:local_variable, 'numbers')
+
+      numbers.lookup(:member, 'one').value.value.should == '1'
+      numbers.lookup(:member, 'two').value.value.should == '2'
+    end
+  end
+end

data/spec/ruby-lint/definitions_builder/assignments/objects.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Building variable definitions' do
+  describe 'object member assignments' do
+    should 'process a single member assignment' do
+      code = <<-CODE
+  person      = OpenStruct.new
+  person.name = 'Matz'
+      CODE
+
+      defs   = build_definitions(code)
+      person = defs.lookup(:local_variable, 'person')
+      name   = person.lookup(:member, 'name')
+
+      name.is_a?(ruby_object).should == true
+      name.name.should               == 'name'
+      name.type.should               == :identifier
+
+      name.value.type.should  == :string
+      name.value.value.should == 'Matz'
+    end
+  end
+end

data/spec/ruby-lint/definitions_builder/assignments/optional.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Building variable definitions' do
+  describe 'optional assignments' do
+    should 'process an assignment for an existing variable' do
+      code = <<-CODE
+number   = 10
+number ||= 20
+      CODE
+
+      defs = build_definitions(code)
+
+      defs.lookup(:local_variable, 'number').value.value.should == '10'
+    end
+
+    should 'process an assignment for a non existing variable' do
+      defs = build_definitions('number ||= 10')
+
+      defs.lookup(:local_variable, 'number').value.value.should == '10'
+    end
+  end
+end

data/spec/ruby-lint/definitions_builder/assignments/return_values.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+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.is_a?(ruby_object).should == true
+
+    value.type.should      == :constant
+    value.name.should      == 'String'
+    value.instance?.should == true
+  end
+
+  it 'should assign a nil value for a missing return value' do
+    code = <<-CODE
+def example
+end
+
+number = example
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:local_variable, '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.is_a?(ruby_object).should == true
+
+    value.type.should      == :constant
+    value.name.should      == 'String'
+    value.instance?.should == true
+  end
+
+  describe 'setting instance types for core Ruby types' do
+    should 'create a new String instance' do
+      defs = build_definitions('number = "10"')
+
+      defs.lookup(:local_variable, '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
+    end
+
+    should 'create a new Fixnum instance' do
+      defs = build_definitions('number = 10')
+
+      defs.lookup(:local_variable, '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
+    end
+
+    should 'create a new Array instance' do
+      defs = build_definitions('number = [10]')
+
+      defs.lookup(:local_variable, '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
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Building variable definitions' do
+  describe 'variables' do
+    should 'process basic variable assignments' do
+      defs   = build_definitions('number = 10')
+      number = defs.lookup(:local_variable, 'number')
+
+      number.is_a?(ruby_object).should == true
+      number.name.should               == 'number'
+
+      number.value.is_a?(ruby_object).should == true
+      number.value.value.should              == '10'
+    end
+
+    should 'process mass variable assignments' do
+      defs    = build_definitions('number, numberx = 10, 20')
+      number  = defs.lookup(:local_variable, 'number')
+      numberx = defs.lookup(:local_variable, '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 'process constant path assignments' do
+      defs = build_definitions('Kernel::FOO = 10')
+      foo  = defs.lookup(:constant, 'Kernel').lookup(:constant, 'FOO')
+
+      foo.is_a?(ruby_object).should == true
+
+      foo.name.should        == 'FOO'
+      foo.value.value.should == '10'
+    end
+
+    should 'process recursive variable assignments' do
+      code = <<-CODE
+  a = 1
+  b = a
+  c = b
+  d = c
+      CODE
+
+      defs = build_definitions(code)
+      var  = defs.lookup(:local_variable, 'd')
+
+      var.value.type.should  == :integer
+      var.value.value.should == '1'
+    end
+
+    should 'handle multiple variable assignments' do
+      code = 'first = second = third = 10'
+      defs = build_definitions(code)
+
+      %w{first second third}.each do |name|
+        variable = defs.lookup(:local_variable, name)
+
+        variable.is_a?(ruby_object).should == true
+
+        variable.value.type.should  == :integer
+        variable.value.value.should == '10'
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Building definitions for blocks' do
+  should 'make outer local variables available to the inside of a block' do
+    code = <<-CODE
+number = 10
+
+example do
+  number_string = number.to_s
+end
+    CODE
+
+    ast     = parse(code, false)
+    builder = RubyLint::DefinitionsBuilder.new
+
+    builder.iterate(ast)
+
+    block  = builder.options[:node_definitions].values.last
+    number = block.lookup(:local_variable, 'number')
+
+    number.is_a?(ruby_object).should == true
+
+    number.value.type.should  == :integer
+    number.value.value.should == '10'
+  end
+
+  should 'use outer local variables when overwriting them' do
+    code = <<-CODE
+number = 10
+
+example do
+  number = 20
+end
+    CODE
+
+    defs = build_definitions(code)
+
+    defs.lookup(:local_variable, 'number').value.value.should == '20'
+  end
+end

data/spec/ruby-lint/definitions_builder/classes.rb

@@ -0,0 +1,230 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Building class definitions' do
+  describe 'scoping definitions' do
+    should 'process a global class' do
+      defs    = build_definitions('class Example; end')
+      example = defs.lookup(:constant, 'Example')
+
+      example.is_a?(ruby_object).should == true
+
+      example.type.should == :class
+      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(:constant, 'First')
+
+      first.is_a?(ruby_object).should == true
+
+      defs.lookup(:constant, 'Second').nil?.should == true
+
+      first.lookup(:constant, '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(:constant, 'First')
+
+      first.lookup(:constant, 'Second').is_a?(ruby_object).should == true
+      first.lookup(:constant, 'Third').is_a?(ruby_object).should == true
+
+      first.lookup(:constant, 'Second') \
+        .lookup(:constant, 'Third') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      defs.lookup(:constant, 'Third').is_a?(ruby_object).should == true
+    end
+  end
+
+  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(:constant, 'First') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+
+  describe 'extending classes' do
+    should 'set the default parent class' do
+      defs = build_definitions('class First; end')
+
+      defs.lookup(:constant, '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(:constant, 'Second') \
+        .parents \
+        .map(&:name) \
+        .should == ['First', 'root']
+
+      defs.lookup(:constant, '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(:constant, 'Third') \
+        .parents \
+        .map(&:name) \
+        .should == ['Second', 'root']
+
+      defs.lookup(:constant, 'Third') \
+        .lookup(:instance_method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+
+  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(:constant, 'Example') \
+        .lookup(:method, 'class_method') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+
+  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(:constant, 'First') \
+        .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(:constant, '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(:constant, 'First') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == false
+
+      defs.lookup(:constant, 'String') \
+        .lookup(:method, 'example') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+
+  describe 'inheriting definitions' do
+    should 'inherit from Object when importing String' do
+      defs = build_definitions('String')
+
+      defs.lookup(:constant, 'String') \
+        .lookup(:method, 'new') \
+        .is_a?(ruby_method) \
+        .should == true
+    end
+  end
+end