ruby-lint 0.0.2 → 0.0.3

data/spec/ruby-lint/definition/method_calls.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe 'Evaluating method calls on RubyObject instances' do
+  before do
+    @object = ruby_object.new(
+      :name          => 'String',
+      :type          => :constant,
+      :instance_type => :instance
+    )
+
+    @method = ruby_method.new(
+      :name         => 'gsub',
+      :type         => :instance_method,
+      :return_value => proc { |object| object.instance }
+    )
+
+    @object.add(@method.type, @method.name, @method)
+  end
+
+  should 'return a instance when evaluating a method call' do
+    value = @object.call(@method.name)
+
+    value.name.should == @object.name
+    value.type.should == @object.type
+  end
+end

data/spec/ruby-lint/definition/ruby_method.rb

@@ -0,0 +1,175 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe ruby_method do
+  before do
+    @method_def = ruby_method.new_from_node(
+      s(
+        :method_definition,
+        'example',
+        s(
+          :arguments,
+          s(:argument, s(:local_variable, 'required')),
+          s(
+            :optional_argument,
+            s(:local_variable, 'number', s(:integer, '10'))
+          ),
+          s(:rest_argument, s(:local_variable, 'rest')),
+          s(:more_argument, s(:local_variable, 'more')),
+          s(:block_argument, s(:local_variable, 'block'))
+        ),
+        s(:constant, 'String'),
+        s(:body, [s(:return, s(:local_variable, 'required'))])
+      )
+    )
+
+    @method_call = ruby_method.new_from_node(
+      s(
+        :method,
+        'example',
+        s(:arguments, s(:argument, s(:integer, '10'))),
+        s(:constant, 'String')
+      )
+    )
+  end
+
+  should 'return the correct method names' do
+    @method_def.name.should  == 'example'
+    @method_call.name.should == 'example'
+  end
+
+  should 'return the correct object types' do
+    @method_def.type.should  == :method_definition
+    @method_call.type.should == :method
+
+    @method_def.method?.should  == false
+    @method_call.method?.should == true
+  end
+
+  should 'return the method definition receiver' do
+    @method_def.receiver.is_a?(ruby_object).should == true
+    @method_def.receiver.name.should               == 'String'
+  end
+
+  should 'return the method call receiver' do
+    @method_call.receiver.is_a?(ruby_object).should == true
+    @method_call.receiver.name.should               == 'String'
+  end
+
+  should 'set the correct method definition type' do
+    @method_def.method_type.should == :method
+  end
+
+  describe 'method definition arguments' do
+    should 'return the required arguments' do
+      @method_def.arguments.length.should == 1
+
+      required = @method_def.arguments[0]
+
+      required.is_a?(ruby_object).should == true
+
+      required.name.should == 'required'
+    end
+
+    should 'return the optional arguments' do
+      @method_def.optional_arguments.length.should == 1
+
+      number = @method_def.optional_arguments[0]
+
+      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 'return the rest argument' do
+      @method_def.rest_argument.nil?.should == false
+      @method_def.rest_argument.name.should == 'rest'
+    end
+
+    should 'return the more arguments' do
+      @method_def.more_arguments.length.should == 1
+
+      param = @method_def.more_arguments[0]
+
+      param.name.should       == 'more'
+      param.value.nil?.should == true
+    end
+
+    should 'return the block argument' do
+      @method_def.block_argument.nil?.should == false
+      @method_def.block_argument.name.should == 'block'
+    end
+
+    should 'add method arguments to the definitions list' do
+      @method_def.lookup(:local_variable, 'required') \
+        .is_a?(ruby_object) \
+        .should == true
+
+      @method_def.lookup(:local_variable, 'block') \
+        .is_a?(ruby_object) \
+        .should == true
+    end
+  end
+
+  describe 'method call arguments' do
+    should 'return the specified arguments' do
+      @method_call.arguments.length.should == 1
+
+      param = @method_call.arguments[0]
+
+      param.is_a?(ruby_object).should == true
+      param.type.should                                    == :integer
+      param.value.should                                   == '10'
+    end
+
+    should 'process a constant path' do
+      method = ruby_method.new_from_node(
+        s(
+          :method,
+          'example',
+          s(
+            :arguments,
+            s(
+              :argument,
+              s(:constant_path, s(:constant, 'First'), s(:constant, 'Second'))
+            )
+          ),
+          nil,
+          nil
+        )
+      )
+
+      param = method.arguments[0]
+
+      param.is_a?(ruby_object).should == true
+      param.type.should == :constant
+      param.name.should == 'Second'
+
+      param.receiver.is_a?(ruby_object).should == true
+      param.receiver.type.should == :constant
+      param.receiver.name.should == 'First'
+    end
+  end
+
+  should 'list all the methods of a class' do
+    klass = ruby_object.new(
+      :type => :class,
+      :name => 'Example'
+    )
+
+    method = ruby_method.new(
+      :name     => 'class_method',
+      :receiver => klass.lookup(:keyword, 'self')
+    )
+
+    klass.add(:method, method.name, method)
+
+    methods = klass.list(:method)
+
+    methods.length.should  == 1
+    methods[0].name.should == 'class_method'
+  end
+end

data/spec/ruby-lint/definition/ruby_object.rb

@@ -0,0 +1,228 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe ruby_object do
+  before do
+    value = ruby_object.new(
+      :type  => :integer,
+      :value => '10'
+    )
+
+    @object = ruby_object.new(
+      :type   => :local_variable,
+      :name   => 'hello',
+      :value  => value
+    )
+  end
+
+  should 'return the name of the object' do
+    @object.name.should == 'hello'
+  end
+
+  should 'return the object type' do
+    @object.type.should == :local_variable
+  end
+
+  should 'return the value of the node' do
+    @object.value.value.should == '10'
+  end
+
+  should 'only store RubyObject objects' do
+    obj = ruby_object.new(
+      :type => :local_variable,
+      :name => 'foo'
+    )
+
+    should.raise?(TypeError) do
+      @object.add(:local_variable, 'foo', 10)
+    end
+
+    should.not.raise?(TypeError) do
+      @object.add(:local_variable, 'foo', obj)
+    end
+  end
+
+  should 'store a variable' do
+    var = ruby_object.new(
+      :type => :local_variable,
+      :name => 'number'
+    )
+
+    @object.add(:local_variable, var.name, var)
+
+    found = @object.lookup(:local_variable, var.name)
+
+    found.is_a?(ruby_object).should == true
+
+    found.name.should == 'number'
+    found.type.should == :local_variable
+  end
+
+  should 'clear all the definitions' do
+    var = ruby_object.new(
+      :type => :local_variable,
+      :name => 'number'
+    )
+
+    @object.add(:local_variable, var.name, var)
+
+    @object.lookup(:local_variable, var.name).nil?.should == false
+
+    @object.clear!
+
+    @object.lookup(:local_variable, var.name).nil?.should == true
+  end
+
+  should 'set the parent definitions' do
+    var1 = ruby_object.new(
+      :type  => :local_variable,
+      :name  => 'numberx',
+      :value => '10'
+    )
+
+    var2 = ruby_object.new(
+      :type    => :local_variable,
+      :name    => 'number',
+      :value   => '10',
+      :parents => [var1]
+    )
+
+    var2.parents.length.should == 1
+  end
+
+  should 'retrieve parent definitions' do
+    method = ruby_object.new(
+      :type => :local_variable,
+      :name => 'example'
+    )
+
+    @object.add(:method, 'example', method)
+
+    child = ruby_object.new(
+      :type    => :class,
+      :name    => 'Example',
+      :parents => [@object]
+    )
+
+    found = child.lookup(:method, 'example')
+
+    found.is_a?(ruby_object).should == true
+
+    found.name.should == 'example'
+  end
+
+  describe 'creating definitions from RubyLint::Node instances' do
+    should 'create a definition for a string' do
+      object = ruby_object.new_from_node(
+        s(:string, 'hello')
+      )
+
+      object.type.should  == :string
+      object.value.should == 'hello'
+    end
+
+    should 'create a definition for a variable with a value' do
+      object = ruby_object.new_from_node(
+        s(:local_variable, 'number'),
+        :value => s(:integer, '10')
+      )
+
+      object.type.should == :local_variable
+      object.name.should == 'number'
+
+      object.value.type.should  == :integer
+      object.value.value.should == '10'
+    end
+
+    should 'create a definition for a constant path' do
+      var = ruby_object.new_from_node(
+        s(
+          :constant_path,
+          s(:constant, 'First'),
+          s(:constant, 'Second'),
+          s(:constant, 'Third')
+        )
+      )
+
+      var.type.should == :constant
+      var.name.should == 'Third'
+
+      var.receiver.name.should == 'Second'
+      var.receiver.type.should == :constant
+
+      var.receiver.receiver.name.should == 'First'
+      var.receiver.receiver.type.should == :constant
+    end
+  end
+
+  should 'return multiple values for a collection' do
+    variable = s(:local_variable, 'numbers')
+    numbers  = s(:array, s(:integer, '10'), s(:integer, '20'))
+    object   = ruby_object.new_from_node(
+      variable,
+      :value => numbers
+    )
+
+    object.value.type.should == :array
+
+    object.value.value.is_a?(Array).should == true
+    object.value.value.length.should       == 2
+
+    values = object.value.value
+
+    values[0].is_a?(ruby_object).should == true
+    values[1].is_a?(ruby_object).should == true
+
+    values[0].value.should == '10'
+    values[1].value.should == '20'
+  end
+
+  should 'create a RubyObject that represents an instance' do
+    object = ruby_object.new(:type => :constant, :name => 'String')
+
+    object.instance_type.should == :class
+
+    instance = object.instance
+
+    instance.type.should          == object.type
+    instance.name.should          == object.name
+    instance.instance_type.should == :instance
+  end
+
+  should 'add data to a parent definition' do
+    initial = ruby_object.new(
+      :type  => :local_variable,
+      :name  => 'test',
+      :value => '10'
+    )
+
+    copy = ruby_object.new(
+      :type  => :local_variable,
+      :name  => 'test',
+      :value => '20'
+    )
+
+    child_only = ruby_object.new(
+      :type  => :local_variable,
+      :name  => 'child_only',
+      :value => '30'
+    )
+
+    parent = ruby_object.new(:name => 'parent')
+    child  = ruby_object.new(
+      :name           => 'child',
+      :update_parents => [:local_variable],
+      :parents        => [parent]
+    )
+
+    parent.add(initial.type, initial.name, initial)
+
+    child.add(initial.type, initial.name, initial)
+    child.add(copy.type, copy.name, copy)
+    child.add(child_only.type, child_only.name, child_only)
+
+    child.lookup(initial.type, initial.name).should  == copy
+    parent.lookup(initial.type, initial.name).should == copy
+
+    parent.lookup(child_only.type, child_only.name).nil?.should == true
+  end
+end

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

@@ -0,0 +1,71 @@
+require File.expand_path('../../../../helper', __FILE__)
+
+describe 'Building variable definitions' do
+  should 'assign arrays 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 'array index assignments' do
+    should 'process single index assignments' do
+      code = <<-CODE
+  numbers    = []
+  numbers[0] = 10
+      CODE
+
+      defs    = build_definitions(code)
+      numbers = defs.lookup(:local_variable, 'numbers')
+
+      numbers.is_a?(ruby_object).should       == true
+      numbers.value.is_a?(ruby_object).should == true
+      numbers.value.type.should               == :array
+
+      first = numbers.lookup(:member, 0)
+
+      first.is_a?(ruby_object).should == true
+      first.type.should               == :integer
+
+      first.value.is_a?(ruby_object).should == true
+      first.value.type.should               == :integer
+      first.value.value.should              == '10'
+    end
+
+    should 'process multiple index assignments' do
+      code = <<-CODE
+numbers        = []
+numbers[0,1]   = 10
+numbers[2,3]   = 20, 30
+numbers[4,5,6] = 40, 50
+      CODE
+
+      defs    = build_definitions(code)
+      numbers = defs.lookup(:local_variable, 'numbers')
+
+      numbers.lookup(:member, '0').value.value.should == '10'
+      numbers.lookup(:member, '1').value.should       == nil
+      numbers.lookup(:member, '2').value.value.should == '20'
+      numbers.lookup(:member, '3').value.value.should == '30'
+      numbers.lookup(:member, '4').value.value.should == '40'
+      numbers.lookup(:member, '5').value.value.should == '50'
+      numbers.lookup(:member, '6').value.should       == nil
+    end
+
+    should 'process index assignments using variables' do
+      code = <<-CODE
+index          = 1
+numbers        = [10]
+numbers[index] = 20
+      CODE
+
+      defs    = build_definitions(code)
+      numbers = defs.lookup(:local_variable, 'numbers')
+
+      numbers.lookup(:member, '0').value.value.should == '10'
+      numbers.lookup(:member, '1').value.value.should == '20'
+    end
+  end
+end