ruby-lint 0.0.3 → 0.0.4

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

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

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

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

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

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

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

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