climine 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/method_handler_spec.rb

@@ -0,0 +1,239 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Handlers::C::MethodHandler do
+  it "should register methods" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      rb_define_method(mFoo, "bar", bar, 0);
+    eof
+    Registry.at('Foo#bar').should_not be_nil
+    Registry.at('Foo#bar').visibility.should == :public
+  end
+
+  it "should register private methods" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      rb_define_private_method(mFoo, "bar", bar, 0);
+    eof
+    Registry.at('Foo#bar').should_not be_nil
+    Registry.at('Foo#bar').visibility.should == :private
+  end
+
+  it "should register singleton methods" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      rb_define_singleton_method(mFoo, "bar", bar, 0);
+    eof
+    Registry.at('Foo.bar').should_not be_nil
+    Registry.at('Foo.bar').visibility.should == :public
+  end
+
+  it "should register module functions" do
+    parse <<-eof
+      /* DOCSTRING
+       * @return [String] foo!
+      */
+      static VALUE bar(VALUE self) { x(); y(); z(); }
+
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_module_function(mFoo, "bar", bar, 0);
+      }
+    eof
+    bar_c = Registry.at('Foo.bar')
+    bar_i = Registry.at('Foo#bar')
+    bar_c.should be_module_function
+    bar_c.visibility.should == :public
+    bar_c.docstring.should == "DOCSTRING"
+    bar_c.tag(:return).object.should == bar_c
+    bar_c.source.should == "static VALUE bar(VALUE self) { x(); y(); z(); }"
+    bar_i.should_not be_module_function
+    bar_i.visibility.should == :private
+    bar_i.docstring.should == "DOCSTRING"
+    bar_i.tag(:return).object.should == bar_i
+    bar_i.source.should == bar_c.source
+  end
+
+  it "should register global functions into Kernel" do
+    parse_init 'rb_define_global_function("bar", bar, 0);'
+    Registry.at('Kernel#bar').should_not be_nil
+  end
+
+  it "should look for symbol containing method source" do
+    parse <<-eof
+      static VALUE foo(VALUE self) { x(); y(); z(); }
+      VALUE bar() { a(); b(); c(); }
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo", foo, 0);
+        rb_define_method(mFoo, "bar", bar, 0);
+      }
+    eof
+    foo = Registry.at('Foo#foo')
+    bar = Registry.at('Foo#bar')
+    foo.source.should == "static VALUE foo(VALUE self) { x(); y(); z(); }"
+    foo.file.should == '(stdin)'
+    foo.line.should == 1
+    bar.source.should == "VALUE bar() { a(); b(); c(); }"
+    bar.file.should == '(stdin)'
+    bar.line.should == 2
+  end
+
+  it "should find docstrings attached to method symbols" do
+    parse <<-eof
+      /* DOCSTRING */
+      static VALUE foo(VALUE self) { x(); y(); z(); }
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo", foo, 0);
+      }
+    eof
+    foo = Registry.at('Foo#foo')
+    foo.docstring.should == 'DOCSTRING'
+  end
+
+  it "should use declaration comments as docstring if there are no others" do
+    parse <<-eof
+      static VALUE foo(VALUE self) { x(); y(); z(); }
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        /* DOCSTRING */
+        rb_define_method(mFoo, "foo", foo, 0);
+        // DOCSTRING!
+        rb_define_method(mFoo, "bar", bar, 0);
+      }
+    eof
+    foo = Registry.at('Foo#foo')
+    foo.docstring.should == 'DOCSTRING'
+    bar = Registry.at('Foo#bar')
+    bar.docstring.should == 'DOCSTRING!'
+  end
+
+  it "should look for symbols in other file" do
+    other = <<-eof
+      /* DOCSTRING! */
+      static VALUE foo() { x(); }
+    eof
+    File.should_receive(:read).with('other.c').and_return(other)
+    parse <<-eof
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo", foo, 0); // in other.c
+      }
+    eof
+    foo = Registry.at('Foo#foo')
+    foo.docstring.should == 'DOCSTRING!'
+    foo.file.should == 'other.c'
+    foo.line.should == 2
+    foo.source.should == 'static VALUE foo() { x(); }'
+  end
+
+  it "should allow extra file to include /'s and other filename characters" do
+    File.should_receive(:read).at_least(1).times.with('ext/a-file.c').and_return(<<-eof)
+      /* FOO */
+      VALUE foo(VALUE x) { int value = x; }
+
+      /* BAR */
+      VALUE bar(VALUE x) { int value = x; }
+    eof
+    parse_init <<-eof
+      rb_define_method(rb_cFoo, "foo", foo, 1); /* in ext/a-file.c */
+      rb_define_global_function("bar", bar, 1); /* in ext/a-file.c */
+    eof
+    Registry.at('Foo#foo').docstring.should == 'FOO'
+    Registry.at('Kernel#bar').docstring.should == 'BAR'
+  end
+
+  it "should warn if other file can't be found" do
+    log.should_receive(:warn).with(/Missing source file `other.c' when parsing Foo#foo/)
+    parse <<-eof
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo", foo, 0); // in other.c
+      }
+    eof
+  end
+
+  it "should look at override comments for docstring" do
+    parse <<-eof
+      /* Document-method: Foo::foo
+       * Document-method: new
+       * Document-method: Foo::Bar#baz
+       * Foo bar!
+       */
+
+      // init comments
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo", foo, 0);
+        rb_define_method(mFoo, "initialize", foo, 0);
+        mBar = rb_define_module_under(mFoo, "Bar");
+        rb_define_method(mBar, "baz", foo, 0);
+      }
+    eof
+    Registry.at('Foo#foo').docstring.should == 'Foo bar!'
+    Registry.at('Foo#initialize').docstring.should == 'Foo bar!'
+    Registry.at('Foo::Bar#baz').docstring.should == 'Foo bar!'
+  end
+
+  it "should look at overrides in other files" do
+    other = <<-eof
+      /* Document-method: Foo::foo
+       * Document-method: new
+       * Document-method: Foo::Bar#baz
+       * Foo bar!
+       */
+    eof
+    File.should_receive(:read).with('foo/bar/other.c').and_return(other)
+    src = <<-eof
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo", foo, 0); // in foo/bar/other.c
+        rb_define_method(mFoo, "initialize", foo, 0); // in foo/bar/other.c
+        mBar = rb_define_module_under(mFoo, "Bar"); // in foo/bar/other.c
+        rb_define_method(mBar, "baz", foo, 0); // in foo/bar/other.c
+      }
+    eof
+    parse(src, 'foo/bar/baz/init.c')
+    Registry.at('Foo#foo').docstring.should == 'Foo bar!'
+    Registry.at('Foo#initialize').docstring.should == 'Foo bar!'
+    Registry.at('Foo::Bar#baz').docstring.should == 'Foo bar!'
+  end
+
+  it "should add return tag on methods ending in '?'" do
+    parse <<-eof
+      /* DOCSTRING */
+      static VALUE foo(VALUE self) { x(); y(); z(); }
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo?", foo, 0);
+      }
+    eof
+    foo = Registry.at('Foo#foo?')
+    foo.docstring.should == 'DOCSTRING'
+    foo.tag(:return).types.should == ['Boolean']
+  end
+
+  it "should not add return tag if return tags exist" do
+    parse <<-eof
+      // @return [String] foo
+      static VALUE foo(VALUE self) { x(); y(); z(); }
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "foo?", foo, 0);
+      }
+    eof
+    foo = Registry.at('Foo#foo?')
+    foo.tag(:return).types.should == ['String']
+  end
+
+  it "should handle casted method names" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      rb_define_method(mFoo, "bar", (METHOD)bar, 0);
+      rb_define_global_function("baz", (METHOD)baz, 0);
+    eof
+    Registry.at('Foo#bar').should_not be_nil
+    Registry.at('Kernel#baz').should_not be_nil
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/mixin_handler_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Handlers::C::MixinHandler do
+  it "should add includes to modules or classes" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      cBar = rb_define_class("Bar", rb_cObject);
+      mBaz = rb_define_module("Baz");
+      rb_include_module(cBar, mFoo);
+      rb_include_module(mBaz, mFoo);
+    eof
+    foo = Registry.at('Foo')
+    bar = Registry.at('Bar')
+    baz = Registry.at('Baz')
+    bar.mixins(:instance).should == [foo]
+    baz.mixins(:instance).should == [foo]
+  end
+
+  it "should add include as proxy if symbol lookup fails" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      rb_include_module(mFoo, mXYZ);
+    eof
+    foo = Registry.at('Foo')
+    foo.mixins(:instance).should == [P('XYZ')]
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/module_handler_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Handlers::C::ClassHandler do
+  it "should register modules" do
+    parse_init 'mFoo = rb_define_module("Foo");'
+    Registry.at('Foo').type.should == :module
+  end
+
+  it "should register classes under namespaces" do
+    parse_init 'mFoo = rb_define_module_under(mBar, "Foo");'
+    Registry.at('Bar::Foo').type.should == :module
+  end
+
+  it "should remember symbol defined with class" do
+    parse_init(<<-eof)
+      cXYZ = rb_define_module("Foo");
+      rb_define_method(cXYZ, "bar", bar, 0);
+    eof
+    Registry.at('Foo').type.should == :module
+    Registry.at('Foo#bar').should_not be_nil
+  end
+
+  it "should not associate declaration comments as module docstring" do
+    parse_init(<<-eof)
+      /* Docstring! */
+      mFoo = rb_define_module("Foo");
+    eof
+    Registry.at('Foo').docstring.should be_blank
+  end
+
+  it "should associate a file with the declaration" do
+    parse_init(<<-eof)
+      mFoo = rb_define_module("Foo");
+    eof
+    Registry.at('Foo').file.should == '(stdin)'
+    Registry.at('Foo').line.should == 2
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/override_comment_handler_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Handlers::C::OverrideCommentHandler do
+  [:class, :module].each do |type|
+    it "should handle Document-#{type}" do
+      parse(<<-eof)
+        void something;
+        /* Document-#{type}: A
+         * Foo bar baz
+         */
+        void
+      eof
+      Registry.at('A').type.should == type
+      Registry.at('A').docstring.should == 'Foo bar baz'
+      Registry.at('A').file.should == '(stdin)'
+      Registry.at('A').line.should == 2
+    end
+  end
+
+  it "should handle multiple class/module combinations" do
+    parse(<<-eof)
+      /* Document-class: A
+       * Document-class: B
+       * Document-module: C
+       * Foo bar baz
+       */
+    eof
+    Registry.at('A').docstring.should == 'Foo bar baz'
+    Registry.at('B').docstring.should == 'Foo bar baz'
+    Registry.at('C').docstring.should == 'Foo bar baz'
+    Registry.at('C').type == :module
+  end
+
+  it "should handle Document-class with inheritance" do
+    parse(<<-eof)
+      /* Document-class: A < B
+       * Foo bar baz
+       */
+      void
+    eof
+    obj = Registry.at('A')
+    obj.type.should == :class
+    obj.docstring.should == 'Foo bar baz'
+    obj.superclass.should == P('B')
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/path_handler_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Handlers::C::PathHandler do
+  it 'should track variable names defined under namespaces' do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
+      rb_define_method(cBar, "foo", foo, 1);
+    eof
+    Registry.at('Foo::Bar').should_not be_nil
+    Registry.at('Foo::Bar#foo').should_not be_nil
+  end
+
+  it 'should track variable names defined under namespaces' do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
+      mBaz = rb_define_module_under(cBar, "Baz");
+      rb_define_method(mBaz, "foo", foo, 1);
+    eof
+    Registry.at('Foo::Bar::Baz').should_not be_nil
+    Registry.at('Foo::Bar::Baz#foo').should_not be_nil
+  end
+
+  it "should handle rb_path2class() calls" do
+    parse_init <<-eof
+      somePath = rb_path2class("Foo::Bar::Baz")
+      mFoo = rb_define_module("Foo");
+      cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
+      mBaz = rb_define_module_under(cBar, "Baz");
+      rb_define_method(somePath, "foo", foo, 1);
+    eof
+    Registry.at('Foo::Bar::Baz#foo').should_not be_nil
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/spec_helper.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+def parse(src, file = '(stdin)')
+  YARD::Registry.clear
+  parser = YARD::Parser::SourceParser.new(:c)
+  parser.file = file
+  parser.parse(StringIO.new(src))
+end
+
+def parse_init(src)
+  YARD::Registry.clear
+  YARD.parse_string("void Init_Foo() {\n#{src}\n}", :c)
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/c/struct_handler_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Handlers::C::StructHandler do
+  after { Registry.clear }
+
+  it "should handle Struct class definitions" do
+    parse_init <<-eof
+      rb_cRange = rb_struct_define_without_accessor(
+          "Range", rb_cFoo, range_alloc,
+          "begin", "end", "excl", NULL);
+    eof
+    Registry.at('Range').type.should == :class
+    Registry.at('Range').superclass.should == P(:Foo)
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/handlers/class_condition_handler_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
+  before(:all) { parse_file :class_condition_handler_001, __FILE__ }
+
+  def verify_method(*names)
+    names.each {|name| Registry.at("A##{name}").should_not be_nil }
+    names.each {|name| Registry.at("A##{name}not").should be_nil }
+  end
+
+  def no_undoc_error(code)
+    lambda { StubbedSourceParser.parse_string(code) }.should_not raise_error
+  end
+
+  it "should parse all unless blocks for complex conditions" do
+    verify_method :g
+  end
+
+  it "should not parse conditionals inside methods" do
+    verify_method :h
+  end
+
+  it "should only parse then block if condition is literal value `true`" do
+    verify_method :p
+  end
+
+  it "should only parse then block if condition is literal integer != 0" do
+    verify_method :o
+  end
+
+  it "should invert block to parse for literal condition if it's an unless block" do
+    verify_method :e
+  end
+
+  it "should handle conditions such as 'defined? VALUE'" do
+    verify_method :j, :k
+  end
+
+  it "should parse all if/elsif blocks for complex conditions" do
+    verify_method :a, :b, :c, :d
+  end
+
+  it "should only parse else block if condition is literal value `false`" do
+    verify_method :q
+  end
+
+  it "should only parse else block if condition is literal integer == 0" do
+    verify_method :n
+  end
+
+  it "should maintain visibility and scope state inside condition" do
+    Registry.at('A#m').visibility.should == :private
+    Registry.at('A#mnot').visibility.should == :private
+  end
+
+  it "should not fail on complex conditions" do
+    log.should_not_receive(:warn)
+    log.should_not_receive(:error)
+    no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
+    no_undoc_error(<<-eof)
+      (<<-TEST) unless defined?(ABCD_MODEL_TEST)
+        'String'
+      TEST
+    eof
+    no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
+  end
+end