ruby-lint 1.1.0 → 2.0.0

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

@@ -1,135 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::Definition::RubyObject do
-  before do
-    @first = ruby_object.new(:name => 'First', :type => :const)
-  end
-
-  describe 'definining constants using a DSL' do
-    example 'define a constant' do
-      @first.define_constant('B')
-
-      @first.lookup(:const, 'B').is_a?(ruby_object).should == true
-    end
-
-    example 'define a constant using a block' do
-      @first.define_constant('B') do |b|
-        b.define_constant('C')
-      end
-
-      @first.lookup(:const, 'B') \
-        .lookup(:const, 'C') \
-        .is_a?(ruby_object) \
-        .should == true
-    end
-
-    example 'inherit from another object' do
-      @first.define_constant('B') do |b|
-        b.define_constant('C')
-      end
-
-      @first.define_constant('D') do |d|
-        d.inherits(@first.lookup(:const, 'B'))
-      end
-
-      @first.lookup(:const, 'D') \
-        .lookup(:const, 'C') \
-        .is_a?(ruby_object) \
-        .should == true
-    end
-
-    example 'define a constant using a constant path' do
-      @first.define_constant('A')
-      @first.define_constant('A::B')
-
-      @first.lookup(:const, 'A') \
-        .lookup(:const, 'B') \
-        .is_a?(ruby_object) \
-        .should == true
-    end
-  end
-
-  describe 'defining methods using a DSL' do
-    example 'define a method' do
-      @first.define_method('example')
-
-      @first.lookup(:method, 'example').is_a?(ruby_method).should == true
-    end
-
-    example 'define an instance method' do
-      @first.define_instance_method('example')
-
-      @first.lookup(:instance_method, 'example') \
-        .is_a?(ruby_method) \
-        .should == true
-    end
-
-    example 'define a method\'s return value' do
-      string = ruby_object.new(:type => :str, :value => 'hello')
-
-      @first.define_method('example') do |example|
-        example.returns(string)
-      end
-
-      @first.lookup(:method, 'example') \
-        .return_value \
-        .is_a?(ruby_object) \
-        .should == true
-    end
-
-    example 'add a required argument' do
-      arg = method_with_argument(@first, :argument).arguments.first
-
-      arg.is_a?(ruby_object).should == true
-      arg.name.should                == 'number'
-    end
-
-    example 'add a optional argument' do
-      arg = method_with_argument(@first, :optional_argument) \
-        .optional_arguments \
-        .first
-
-      arg.is_a?(ruby_object).should == true
-      arg.name.should                == 'number'
-    end
-
-    example 'add a rest argument' do
-      arg = method_with_argument(@first, :rest_argument).rest_argument
-
-      arg.is_a?(ruby_object).should == true
-      arg.name.should                == 'number'
-    end
-
-    example 'add a block argument' do
-      arg = method_with_argument(@first, :block_argument).block_argument
-
-      arg.is_a?(ruby_object).should == true
-      arg.name.should                == 'number'
-    end
-
-    example 'easily define constructor methods' do
-      @first.define_constructors do |method|
-        method.define_argument('name')
-      end
-
-      @first.lookup(:method, 'new').arguments[0].name.should == 'name'
-
-      @first.lookup(:instance_method, 'initialize') \
-        .arguments[0] \
-        .name \
-        .should == 'name'
-    end
-  end
-
-  describe 'defining global variables using a DSL' do
-    example 'define a global variable' do
-      @first.define_global_variable('$number', '10')
-
-      found = @first.lookup(:gvar, '$number')
-
-      found.is_a?(ruby_object).should == true
-      found.type.should               == :gvar
-      found.name.should               == '$number'
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::Definition::Registry do
-  before do
-    @registry = RubyLint::Definition::Registry.new
-  end
-
-  context 'registering definitions' do
-    example 'no definitions should be registered by default' do
-      @registry.registered.empty?.should == true
-    end
-
-    example 'register a definition' do
-      @registry.register('String') { }
-
-      @registry.registered.key?('String').should == true
-    end
-  end
-
-  context 'checking if definitions exist' do
-    example 'check for a non existing definition' do
-      @registry.include?('Foo').should == false
-    end
-
-    example 'check for an existing definition' do
-      @registry.register('Foo') { }
-
-      @registry.include?('Foo').should == true
-    end
-  end
-
-  context 'retrieving definitions' do
-    example 'raise when the constant does not exist' do
-      lambda { @registry.get('Foo') }.should raise_error(ArgumentError)
-    end
-
-    example 'return the definition when it exists' do
-      @registry.register('Foo') { }
-
-      @registry.get('Foo').is_a?(Proc).should == true
-    end
-  end
-
-  context 'applying definitions' do
-    before do
-      @root = ruby_object.new
-
-      @registry.register('Foo') do |defs|
-        defs.define_constant('Foo') do |foo|
-          foo.define_method('bar')
-        end
-      end
-
-      @registry.apply('Foo', @root)
-    end
-
-    example 'define the constant' do
-      @root.has_definition?(:const, 'Foo').should == true
-    end
-
-    example 'define sub definitions correctly' do
-      @root.lookup(:const, 'Foo')
-        .has_definition?(:method, 'bar')
-        .should == true
-    end
-
-    example 'do not overwrite existing definitions' do
-      foo = @root.lookup(:const, 'Foo')
-
-      @registry.apply('Foo', @root)
-
-      @root.lookup(:const, 'Foo').should == foo
-    end
-  end
-
-  context 'managing load paths' do
-    before do
-      @registry = RubyLint::Definition::Registry.new
-    end
-
-    example 'use the default load path' do
-      @registry.load_path
-        .should == RubyLint::Definition::Registry::DEFAULT_LOAD_PATH
-    end
-
-    example 'add a path to the load path' do
-      @registry.load_path << 'foo'
-
-      @registry.load_path.include?('foo').should == true
-    end
-  end
-
-  context 'loading constant definitions from the load path' do
-    before do
-      RubyLint.registry.load('Rational')
-    end
-
-    example 'load the String constant' do
-      RubyLint.registry.loaded_constants.include?('Rational').should == true
-    end
-
-    example 'register the String definition' do
-      RubyLint.registry.include?('Rational').should == true
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe RubyLint::Definition::RubyObject do
-  context 'method definition DSL' do
-    before do
-      @method = ruby_method.new(:name => 'example', :type => :instance_method)
-    end
-
-    context 'return values' do
-      example 'return a static value' do
-        @method.returns(10)
-
-        @method.return_value.should == 10
-      end
-
-      example 'return a value using a block' do
-        @method.returns do
-          20
-        end
-
-        @method.return_value.is_a?(Proc).should == true
-        @method.return_value.call.should        == 20
-      end
-    end
-
-    context 'calling methods' do
-      before do
-        @method.returns(10)
-      end
-
-      example 'call the method directly' do
-        @method.call.should == 10
-      end
-
-      example 'call the method by name' do
-        container = ruby_object.new(
-          :name          => 'String',
-          :type          => :const,
-          :instance_type => :instance
-        )
-
-        container.add_definition(@method)
-
-        container.call_method('example').should == 10
-      end
-
-      example 'raise for calling an undefined method' do
-        container = ruby_object.new(
-          :name          => 'String',
-          :type          => :const,
-          :instance_type => :instance
-        )
-
-        lambda { container.call_method('derp') }
-          .should raise_error(NoMethodError, /undefined method derp for/i)
-      end
-    end
-
-    context 'defining arguments' do
-      example 'define an argument' do
-        @method.define_argument('number')
-
-        @method.lookup(:arg, 'number').is_a?(ruby_object).should  == true
-        @method.lookup(:lvar, 'number').is_a?(ruby_object).should == true
-
-        @method.arguments[0].is_a?(ruby_object).should == true
-      end
-
-      example 'define an optional argument' do
-        @method.define_optional_argument('number')
-
-        @method.lookup(:optarg, 'number').is_a?(ruby_object).should == true
-        @method.lookup(:lvar, 'number').is_a?(ruby_object).should   == true
-
-        @method.optional_arguments[0].is_a?(ruby_object).should == true
-      end
-
-      example 'define a rest argument' do
-        @method.define_rest_argument('number')
-
-        @method.lookup(:restarg, 'number').is_a?(ruby_object).should == true
-        @method.lookup(:lvar, 'number').is_a?(ruby_object).should    == true
-
-        @method.rest_argument.is_a?(ruby_object).should == true
-      end
-
-      example 'define a block argument' do
-        @method.define_block_argument('number')
-
-        @method.lookup(:blockarg, 'number').is_a?(ruby_object).should == true
-        @method.lookup(:lvar, 'number').is_a?(ruby_object).should     == true
-
-        @method.block_argument.is_a?(ruby_object).should == true
-      end
-
-      example 'define a keyword argument' do
-        @method.define_keyword_argument('number')
-
-        @method.lookup(:kwoptarg, 'number').is_a?(ruby_object).should == true
-        @method.lookup(:lvar, 'number').is_a?(ruby_object).should     == true
-
-        @method.keyword_arguments[0].is_a?(ruby_object).should == true
-      end
-    end
-  end
-end

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

@@ -1,264 +0,0 @@
-require 'spec_helper'
-
-describe ruby_object do
-  before do
-    value = ruby_object.new(
-      :type  => :int,
-      :value => '10'
-    )
-
-    @object = ruby_object.new(
-      :type   => :lvar,
-      :name   => 'hello',
-      :value  => value
-    )
-  end
-
-  example 'return the name of the object' do
-    @object.name.should == 'hello'
-  end
-
-  example 'return the object type' do
-    @object.type.should == :lvar
-  end
-
-  example 'return the value of the node' do
-    @object.value.value.should == '10'
-  end
-
-  example 'only store RubyObject objects' do
-    obj = ruby_object.new(
-      :type => :lvar,
-      :name => 'foo'
-    )
-
-    lambda { @object.add(:lvar, 'foo', 10) }.should raise_error(TypeError)
-    lambda { @object.add(:lvar, 'foo', obj) }.should_not raise_error
-  end
-
-  example 'only add valid collection types' do
-    obj = ruby_object.new(:name => 'Foo', :type => :test)
-
-    lambda { @object.add_definition(obj) }.should raise_error(ArgumentError)
-  end
-
-  example '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)
-
-    second.add_definition(third)
-    first.add_definition(second)
-
-    first.lookup_constant_path('B::C').should == third
-  end
-
-  example 'store a variable' do
-    var = ruby_object.new(
-      :type => :lvar,
-      :name => 'number'
-    )
-
-    @object.add(:lvar, var.name, var)
-
-    found = @object.lookup(:lvar, var.name)
-
-    found.is_a?(ruby_object).should == true
-
-    found.name.should == 'number'
-    found.type.should == :lvar
-  end
-
-  example 'set the parent definitions' do
-    var1 = ruby_object.new(
-      :type  => :lvar,
-      :name  => 'numberx',
-      :value => '10'
-    )
-
-    var2 = ruby_object.new(
-      :type    => :lvar,
-      :name    => 'number',
-      :value   => '10',
-      :parents => [var1]
-    )
-
-    var2.parents.length.should == 1
-  end
-
-  example 'retrieve parent definitions' do
-    method = ruby_object.new(
-      :type => :lvar,
-      :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
-
-  example 'create a shim of a definition' do
-    object = ruby_object.new(:type => :const, :name => 'Foo')
-    shim   = object.shim
-
-    shim.name.should    == object.name
-    shim.parents.should == [object]
-  end
-
-  example 'create a RubyObject that represents an instance' do
-    object = ruby_object.new(:type => :const, :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
-
-  example 'add data to a parent definition' do
-    initial = ruby_object.new(
-      :type  => :lvar,
-      :name  => 'test',
-      :value => '10'
-    )
-
-    copy = ruby_object.new(
-      :type  => :lvar,
-      :name  => 'test',
-      :value => '20'
-    )
-
-    child_only = ruby_object.new(
-      :type  => :lvar,
-      :name  => 'child_only',
-      :value => '30'
-    )
-
-    parent = ruby_object.new(:name => 'parent')
-    child  = ruby_object.new(
-      :name           => 'child',
-      :update_parents => [:lvar],
-      :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
-
-  example '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
-
-  example 'merging two definitions' do
-    source = ruby_object.new(:type => :const, :name => 'Source')
-    target = ruby_object.new(:type => :const, :name => 'Target')
-    const  = ruby_object.new(:type => :const, :name => 'Foo')
-
-    source.add_definition(const)
-
-    target.merge(source)
-
-    target.lookup(:const, 'Foo').should == const
-  end
-
-  example 'storing location information in a definition' do
-    obj = ruby_object.new(:line => 10, :column => 3, :file => '(ruby-lint)')
-
-    obj.line.should   == 10
-    obj.column.should == 3
-    obj.file.should   == '(ruby-lint)'
-  end
-
-  context 'defining self' do
-    before do
-      @class    = ruby_object.new(:instance_type => :class)
-      @instance = ruby_object.new(:instance_type => :instance)
-
-      @class.define_self
-      @instance.define_self
-    end
-
-    example 'define instance level self for an instance' do
-      @instance.lookup(:instance_method, 'self')
-        .return_value
-        .should == @instance
-    end
-
-    example 'define class level self for an instance' do
-      @instance.lookup(:method, 'self')
-        .return_value
-        .parents
-        .should == [@instance]
-    end
-
-    example 'define instance level self for a class' do
-      @class.lookup(:instance_method, 'self')
-        .return_value
-        .parents
-        .should == [@class]
-    end
-
-    example 'define class level self for a class' do
-      @class.lookup(:method, 'self').return_value.should == @class
-    end
-  end
-
-  context 'constant proxies' do
-    before do
-      @root  = ruby_object.new(:type => :const, :name => 'Foo')
-      @proxy = @root.constant_proxy('Bar')
-    end
-
-    example 'create a constant proxy' do
-      @proxy.is_a?(RubyLint::Definition::ConstantProxy).should == true
-    end
-
-    example 'point to the definition when it exists' do
-      baz = @root.define_constant('Bar').define_constant('Baz')
-
-      @proxy.lookup(:const, 'Baz').should == baz
-    end
-  end
-end