ruby-lint 0.0.3 → 0.0.4

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

@@ -3,12 +3,12 @@ require File.expand_path('../../../helper', __FILE__)
 describe ruby_object do
   before do
     value = ruby_object.new(
-      :type  => :integer,
+      :type  => :int,
       :value => '10'
     )
 
     @object = ruby_object.new(
-      :type   => :local_variable,
+      :type   => :lvar,
       :name   => 'hello',
       :value  => value
     )
@@ -19,7 +19,7 @@ describe ruby_object do
   end
 
   should 'return the object type' do
-    @object.type.should == :local_variable
+    @object.type.should == :lvar
   end
 
   should 'return the value of the node' do
@@ -28,59 +28,63 @@ describe ruby_object do
 
   should 'only store RubyObject objects' do
     obj = ruby_object.new(
-      :type => :local_variable,
+      :type => :lvar,
       :name => 'foo'
     )
 
     should.raise?(TypeError) do
-      @object.add(:local_variable, 'foo', 10)
+      @object.add(:lvar, 'foo', 10)
     end
 
     should.not.raise?(TypeError) do
-      @object.add(:local_variable, 'foo', obj)
+      @object.add(:lvar, 'foo', obj)
     end
   end
 
-  should 'store a variable' do
-    var = ruby_object.new(
-      :type => :local_variable,
-      :name => 'number'
-    )
+  should 'only add valid collection types' do
+    obj = ruby_object.new(:name => 'Foo', :type => :test)
 
-    @object.add(:local_variable, var.name, var)
+    should.raise?(ArgumentError) do
+      @object.add_definition(obj)
+    end
+  end
 
-    found = @object.lookup(:local_variable, var.name)
+  should 'look up a constant path' do
+    first  = ruby_object.new(:name => 'A', :type => :const)
+    second = ruby_object.new(:name => 'B', :type => :const)
+    third  = ruby_object.new(:name => 'C', :type => :const)
 
-    found.is_a?(ruby_object).should == true
+    second.add_definition(third)
+    first.add_definition(second)
 
-    found.name.should == 'number'
-    found.type.should == :local_variable
+    first.lookup_constant_path('B::C').should == third
   end
 
-  should 'clear all the definitions' do
+  should 'store a variable' do
     var = ruby_object.new(
-      :type => :local_variable,
+      :type => :lvar,
       :name => 'number'
     )
 
-    @object.add(:local_variable, var.name, var)
+    @object.add(:lvar, var.name, var)
 
-    @object.lookup(:local_variable, var.name).nil?.should == false
+    found = @object.lookup(:lvar, var.name)
 
-    @object.clear!
+    found.is_a?(ruby_object).should == true
 
-    @object.lookup(:local_variable, var.name).nil?.should == true
+    found.name.should == 'number'
+    found.type.should == :lvar
   end
 
   should 'set the parent definitions' do
     var1 = ruby_object.new(
-      :type  => :local_variable,
+      :type  => :lvar,
       :name  => 'numberx',
       :value => '10'
     )
 
     var2 = ruby_object.new(
-      :type    => :local_variable,
+      :type    => :lvar,
       :name    => 'number',
       :value   => '10',
       :parents => [var1]
@@ -91,7 +95,7 @@ describe ruby_object do
 
   should 'retrieve parent definitions' do
     method = ruby_object.new(
-      :type => :local_variable,
+      :type => :lvar,
       :name => 'example'
     )
 
@@ -110,74 +114,8 @@ describe ruby_object do
     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 = ruby_object.new(:type => :const, :name => 'String')
 
     object.instance_type.should == :class
 
@@ -190,19 +128,19 @@ describe ruby_object do
 
   should 'add data to a parent definition' do
     initial = ruby_object.new(
-      :type  => :local_variable,
+      :type  => :lvar,
       :name  => 'test',
       :value => '10'
     )
 
     copy = ruby_object.new(
-      :type  => :local_variable,
+      :type  => :lvar,
       :name  => 'test',
       :value => '20'
     )
 
     child_only = ruby_object.new(
-      :type  => :local_variable,
+      :type  => :lvar,
       :name  => 'child_only',
       :value => '30'
     )
@@ -210,7 +148,7 @@ describe ruby_object do
     parent = ruby_object.new(:name => 'parent')
     child  = ruby_object.new(
       :name           => 'child',
-      :update_parents => [:local_variable],
+      :update_parents => [:lvar],
       :parents        => [parent]
     )
 
@@ -225,4 +163,30 @@ describe ruby_object do
 
     parent.lookup(child_only.type, child_only.name).nil?.should == true
   end
+
+  should 'return the members as the definition value' do
+    array  = ruby_object.new(:type => :array, :members_as_value => true)
+    values = [10, 20]
+
+    values.each_with_index do |value, index|
+      value  = ruby_object.new(:type => :int, :value => value)
+      member = ruby_object.new(
+        :type  => :member,
+        :name  => index.to_s,
+        :value => value
+      )
+
+      array.add(member.type, member.name, member)
+    end
+
+    array.value.is_a?(Array).should == true
+    array.value.length.should       == 2
+
+    values.each_with_index do |value, index|
+      array.value[index].name.should == index.to_s
+
+      array.value[index].value.type.should  == :int
+      array.value[index].value.value.should == value
+    end
+  end
 end

data/spec/ruby-lint/definition_builder/primitive.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::DefinitionBuilder::Primitive do
+  before do
+    @root = ruby_object.new(:name => 'root')
+  end
+
+  should 'build an integer definition' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @root)
+    built   = builder.build
+
+    built.type.should  == :int
+    built.value.should == 10
+  end
+
+  should 'build a float definition' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:float, 10.0), @root)
+    built   = builder.build
+
+    built.type.should  == :float
+    built.value.should == 10.0
+  end
+
+  should 'build a string definition' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:str, 'a'), @root)
+    built   = builder.build
+
+    built.type.should  == :str
+    built.value.should == 'a'
+  end
+
+  should 'build a symbol definition' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:sym, :a), @root)
+    built   = builder.build
+
+    built.type.should  == :sym
+    built.value.should == :a
+  end
+
+  should 'build primitives as instances by default' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @root)
+
+    builder.build.instance?.should == true
+  end
+
+  should 'allow custom options to be defined' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(
+      s(:int, 10),
+      @root,
+      :instance_type => :class
+    )
+
+    builder.build.class?.should == true
+  end
+
+  should 'include the definitions of the corresponding Ruby class' do
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @root)
+    built   = builder.build
+
+    built.lookup(:instance_method, 'to_s').is_a?(ruby_object).should == true
+  end
+end

data/spec/ruby-lint/definition_builder/ruby_class.rb

@@ -0,0 +1,108 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::DefinitionBuilder::RubyClass do
+  describe 'using an implicit parent class' do
+    before do
+      node     = s(:class, s(:const, nil, :A), nil, s(:nil))
+      @root    = ruby_object.new(:name => 'root')
+      @builder = RubyLint::DefinitionBuilder::RubyClass.new(node, @root)
+    end
+
+    should 'return the name of the class' do
+      @builder.build.name.should == 'A'
+    end
+
+    should 'return the type of the class' do
+      @builder.build.type.should == :const
+    end
+
+    should 'return the parent definitions' do
+      built = @builder.build
+
+      built.parents.length.should == 2
+
+      built.parents[0].name.should == 'Object'
+      built.parents[1].name.should == 'root'
+    end
+
+    should 'return the reference amount' do
+      @builder.build.reference_amount.should == 1
+    end
+
+    should 'return the scope to define the class in' do
+      @builder.scope.should == @root
+    end
+  end
+
+  describe 'using an explicit parent class' do
+    before do
+      node  = s(:class, s(:const, nil, :A), s(:const, nil, :B), s(:nil))
+      @root = ruby_object.new(:name => 'root')
+
+      @root.define_constant('B')
+
+      @builder = RubyLint::DefinitionBuilder::RubyClass.new(
+        node,
+        @root,
+        :parent => @root.lookup(:const, 'B')
+      )
+    end
+
+    should 'return the name of the class' do
+      @builder.build.name.should == 'A'
+    end
+
+    should 'return the parent definitions' do
+      built = @builder.build
+
+      built.parents.length.should == 2
+
+      built.parents[0].name.should == 'B'
+      built.parents[1].name.should == 'root'
+    end
+
+    should 'return the scope to define the class in' do
+      @builder.scope.should == @root
+    end
+  end
+
+  describe 'using constant paths' do
+    before do
+      node = s(
+        :class,
+        s(:const, s(:const, nil, :A), :B),
+        s(:const, s(:const, nil, :C), :D),
+        s(:nil)
+      )
+
+      @root = ruby_object.new(:name => 'root')
+
+      @root.define_constant('A')
+
+      d_const = @root.define_constant('C').define_constant('D')
+
+      @builder = RubyLint::DefinitionBuilder::RubyClass.new(
+        node,
+        @root,
+        :parent => d_const
+      )
+    end
+
+    should 'return the name of the class' do
+      @builder.build.name.should == 'B'
+    end
+
+    should 'return the parent definitions' do
+      built = @builder.build
+
+      built.parents.length.should == 2
+
+      built.parents[0].name.should == 'D'
+      built.parents[1].name.should == 'root'
+    end
+
+    should 'return the scope to define the class in' do
+      @builder.scope.should == @root.lookup(:const, 'A')
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require File.expand_path('../../../helper', __FILE__)
+
+describe RubyLint::DefinitionBuilder::RubyMethod do
+  describe 'defining a method without a receiver' do
+    before do
+      node     = s(:def, :example, s(:args), s(:nil))
+      @root    = ruby_object.new(:name => 'root', :instance_type => :instance)
+      @builder = RubyLint::DefinitionBuilder::RubyMethod.new(node, @root)
+    end
+
+    should 'return the name of the method' do
+      @builder.build.name.should == 'example'
+    end
+
+    should 'return the type of the method' do
+      @builder.build.type.should == :instance_method
+    end
+
+    should 'return the parent definitions' do
+      @builder.build.parents.should == [@root]
+    end
+
+    should 'return the scope to define the method in' do
+      @builder.scope.should == @root
+    end
+  end
+
+  describe 'defining a method with a constant as a receiver' do
+    before do
+      node    = s(:defs, s(:const, nil, :A), :example, s(:args), s(:nil))
+      @root   = ruby_object.new(:name => 'root', :instance_type => :instance)
+      a_const = @root.define_constant('A')
+
+      @builder = RubyLint::DefinitionBuilder::RubyMethod.new(
+        node,
+        @root,
+        :receiver => a_const
+      )
+    end
+
+    should 'return the name of the method' do
+      @builder.build.name.should == 'example'
+    end
+
+    should 'return the parent definitions' do
+      @builder.build.parents.should == [@root.lookup(:const, 'A')]
+    end
+
+    should 'return the scope to define the method in' do
+      @builder.scope.should == @root.lookup(:const, 'A')
+    end
+  end
+end