sidekiq-statsd 0.1.0 → 0.1.1

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/spec/tags/directives_spec.rb

@@ -0,0 +1,436 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+def tag_parse(content, object = nil, handler = nil)
+  @parser = DocstringParser.new
+  @parser.parse(content, object, handler)
+  @parser
+end
+
+describe YARD::Tags::ParseDirective do
+  describe '#call' do
+    after { Registry.clear }
+
+    it "should parse if handler=nil but use file=(stdin)" do
+      tag_parse %{@!parse
+        # Docstring here
+        def foo; end
+      }
+      Registry.at('#foo').docstring.should == "Docstring here"
+      Registry.at('#foo').file.should == '(stdin)'
+    end
+
+    it "should allow parser type to be specified in type" do
+      tag_parse %{@!parse [c]
+        void Init_Foo() {
+          rb_define_method(rb_cMyClass, "foo", foo, 1);
+        }
+      }
+      Registry.at('MyClass#foo').should_not be_nil
+    end
+
+    it "should parse code in context of current handler" do
+      src = <<-eof
+        class A
+          # @!parse
+          #   def foo; end
+          eval "def foo; end"
+        end
+      eof
+      parser = Parser::SourceParser.new
+      parser.file = "myfile.rb"
+      parser.parse(StringIO.new(src))
+      Registry.at('A#foo').file.should == 'myfile.rb'
+    end
+  end
+end
+
+describe YARD::Tags::GroupDirective do
+  describe '#call' do
+    it "should do nothing if handler=nil" do
+      tag_parse("@!group foo")
+    end
+
+    it "should set group value in parser state (with handler)" do
+      handler = OpenStruct.new(:extra_state => OpenStruct.new)
+      tag_parse("@!group foo", nil, handler)
+      handler.extra_state.group.should == 'foo'
+    end
+  end
+end
+
+describe YARD::Tags::EndGroupDirective do
+  describe '#call' do
+    it "should do nothing if handler=nil" do
+      tag_parse("@!endgroup foo")
+    end
+
+    it "should set group value in parser state (with handler)" do
+      handler = OpenStruct.new(:extra_state => OpenStruct.new(:group => "foo"))
+      tag_parse("@!endgroup", nil, handler)
+      handler.extra_state.group.should be_nil
+    end
+  end
+end
+
+describe YARD::Tags::MacroDirective do
+  def handler
+    OpenStruct.new(:call_params => %w(a b c),
+                   :caller_method => 'foo',
+                   :scope => :instance, :visibility => :public,
+                   :namespace => P('Foo::Bar'),
+                   :statement => OpenStruct.new(:source => 'foo :a, :b, :c'))
+  end
+
+  after(:all) { Registry.clear }
+
+  describe '#call' do
+    it "should define new macro when [new] is provided" do
+      tag_parse("@!macro [new] foo\n  foo")
+      CodeObjects::MacroObject.find('foo').macro_data.should == 'foo'
+    end
+
+    it "should define new macro if text block is provided" do
+      tag_parse("@!macro bar\n  bar")
+      CodeObjects::MacroObject.find('bar').macro_data.should == 'bar'
+    end
+
+    it "should expand macros and return #expanded_text to tag parser" do
+      tag_parse("@!macro [new] foo\n  foo")
+      tag_parse("@!macro foo").text.should == 'foo'
+    end
+
+    it "should not expand new macro if docstring is unattached" do
+      tag_parse("@!macro [new] foo\n  foo").text.should_not == 'foo'
+    end
+
+    it "should expand new anonymous macro even if docstring is unattached" do
+      tag_parse("@!macro\n  foo").text.should == 'foo'
+    end
+
+    it "should allow multiple macros to be expanded" do
+      tag_parse("@!macro [new] foo\n  foo")
+      tag_parse("@!macro bar\n  bar")
+      tag_parse("@!macro foo\n@!macro bar").text.should == "foo\nbar"
+    end
+
+    it "should allow anonymous macros" do
+      tag_parse("@!macro\n  a b c", nil, handler)
+      @parser.text.should == 'a b c'
+    end
+
+    it "should expand call_params and caller_method using $N when handler is provided" do
+      tag_parse("@!macro\n  $1 $2 $3", nil, handler)
+      @parser.text.should == 'a b c'
+    end
+
+    it "should attach macro to method if one exists" do
+      tag_parse("@!macro [attach] attached\n  $1 $2 $3", nil, handler)
+      macro = CodeObjects::MacroObject.find('attached')
+      macro.method_object.should == P('Foo::Bar.foo')
+    end
+
+    it "should not expand new attached macro if defined on class method" do
+      baz = CodeObjects::MethodObject.new(P('Foo::Bar'), :baz, :class)
+      baz.visibility.should == :public
+      tag_parse("@!macro [attach] attached2\n  @!visibility private", baz, handler)
+      macro = CodeObjects::MacroObject.find('attached2')
+      macro.method_object.should == P('Foo::Bar.baz')
+      baz.visibility.should == :public
+    end
+
+    it "should expand macro if defined on class method and there is no data block" do
+      tag_parse("@!macro [new] attached3\n  expanded_data")
+      baz = CodeObjects::MethodObject.new(P('Foo::Bar'), :baz, :class)
+      doc = DocstringParser.new.parse('@!macro attached3', baz, handler).to_docstring
+      doc.should == 'expanded_data'
+    end
+
+    it "should not attempt to expand macro values if handler = nil" do
+      tag_parse("@!macro [attach] xyz\n  $1 $2 $3")
+    end
+  end
+end
+
+describe YARD::Tags::MethodDirective do
+  describe '#call' do
+    after { Registry.clear }
+
+    it "should use entire docstring if no indented data is found" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @!method foo
+          # @!method bar
+          # @!scope class
+        end
+      eof
+      Registry.at('Foo.foo').should be_a(CodeObjects::MethodObject)
+      Registry.at('Foo.bar').should be_a(CodeObjects::MethodObject)
+    end
+
+    it "should handle indented block text in @!method" do
+      YARD.parse_string <<-eof
+        # @!method foo(a)
+        #   Docstring here
+        #   @return [String] the foo
+        # Ignore this
+        # @param [String] a
+      eof
+      foo = Registry.at('#foo')
+      foo.docstring.should == "Docstring here"
+      foo.docstring.tag(:return).should_not be_nil
+      foo.tag(:param).should be_nil
+    end
+
+    it "should execute directives on object in indented block" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @!method foo(a)
+          #   @!scope class
+          #   @!visibility private
+          # @!method bar
+          #   Hello
+          # Ignore this
+        end
+      eof
+      foo = Registry.at('Foo.foo')
+      foo.visibility.should == :private
+      bar = Registry.at('Foo#bar')
+      bar.visibility.should == :public
+    end
+
+    it "should be able to define multiple @methods in docstring" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @!method foo1
+          #   Docstring1
+          # @!method foo2
+          #   Docstring2
+          # @!method foo3
+          #   @!scope class
+          #   Docstring3
+        end
+      eof
+      foo1 = Registry.at('Foo#foo1')
+      foo2 = Registry.at('Foo#foo2')
+      foo3 = Registry.at('Foo.foo3')
+      foo1.docstring.should == 'Docstring1'
+      foo2.docstring.should == 'Docstring2'
+      foo3.docstring.should == 'Docstring3'
+    end
+
+    it "should define the method inside namespace if attached to namespace object" do
+      YARD.parse_string <<-eof
+        module Foo
+          # @!method foo
+          #   Docstring1
+          # @!method bar
+          #   Docstring2
+          class Bar
+          end
+        end
+      eof
+      Registry.at('Foo::Bar#foo').docstring.should == 'Docstring1'
+      Registry.at('Foo::Bar#bar').docstring.should == 'Docstring2'
+    end
+
+    it "should set scope to class if signature has 'self.' prefix" do
+      YARD.parse_string <<-eof
+        # @!method self.foo
+        # @!method self. bar
+        # @!method self.baz()
+        class Foo
+        end
+      eof
+      %w(foo bar baz).each do |name|
+        Registry.at("Foo.#{name}").should be_a(CodeObjects::MethodObject)
+      end
+    end
+
+    it "should define parameters from signature" do
+      YARD.parse_string <<-eof
+        # @!method foo(a, b, c = nil)
+      eof
+      Registry.at('#foo').parameters.should == [['a', nil], ['b', nil], ['c', 'nil']]
+    end
+
+    it "should be able to define method with module scope (module function)" do
+      YARD.parse_string <<-eof
+        # @!method foo
+        #   @!scope module
+        #   This is a docstring
+        #   @return [Boolean] whether this is true
+        class Foo
+        end
+      eof
+      foo_c = Registry.at('Foo.foo')
+      foo_i = Registry.at('Foo#foo')
+      foo_c.should_not be_nil
+      foo_i.should_not be_nil
+      foo_c.should be_module_function
+      foo_c.docstring.should == foo_i.docstring
+      foo_c.tag(:return).text.should == foo_i.tag(:return).text
+    end
+  end
+end
+
+describe YARD::Tags::AttributeDirective do
+  describe '#call' do
+    after { Registry.clear }
+
+    it "should use entire docstring if no indented data is found" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @!attribute foo
+          # @!attribute bar
+          # @!scope class
+        end
+      eof
+      Registry.at('Foo.foo').should be_reader
+      Registry.at('Foo.bar').should be_reader
+    end
+
+    it "should handle indented block in @!attribute" do
+      YARD.parse_string <<-eof
+        # @!attribute foo
+        #   Docstring here
+        #   @return [String] the foo
+        # Ignore this
+        # @param [String] a
+      eof
+      foo = Registry.at('#foo')
+      foo.is_attribute?.should == true
+      foo.docstring.should == "Docstring here"
+      foo.docstring.tag(:return).should_not be_nil
+      foo.tag(:param).should be_nil
+    end
+
+    it "should be able to define multiple @attributes in docstring" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @!attribute [r] foo1
+          #   Docstring1
+          # @!attribute [w] foo2
+          #   Docstring2
+          # @!attribute foo3
+          #   @!scope class
+          #   Docstring3
+        end
+      eof
+      foo1 = Registry.at('Foo#foo1')
+      foo2 = Registry.at('Foo#foo2=')
+      foo3 = Registry.at('Foo.foo3')
+      foo4 = Registry.at('Foo.foo3=')
+      foo1.should be_reader
+      foo2.should be_writer
+      foo3.should be_reader
+      foo1.docstring.should == 'Docstring1'
+      foo2.docstring.should == 'Docstring2'
+      foo3.docstring.should == 'Docstring3'
+      foo4.should be_writer
+      foo1.attr_info[:write].should be_nil
+      foo2.attr_info[:read].should be_nil
+    end
+
+    it "should define the attr inside namespace if attached to namespace object" do
+      YARD.parse_string <<-eof
+        module Foo
+          # @!attribute [r] foo
+          # @!attribute [r] bar
+          class Bar
+          end
+        end
+      eof
+      Registry.at('Foo::Bar#foo').should be_reader
+      Registry.at('Foo::Bar#bar').should be_reader
+    end
+  end
+
+  it "should set scope to class if signature has 'self.' prefix" do
+    YARD.parse_string <<-eof
+      # @!attribute self.foo
+      # @!attribute self. bar
+      # @!attribute self.baz
+      class Foo
+      end
+    eof
+    %w(foo bar baz).each do |name|
+      Registry.at("Foo.#{name}").should be_reader
+    end
+  end
+end
+
+describe YARD::Tags::ScopeDirective do
+  describe '#call' do
+    after { Registry.clear }
+
+    it "should set state on tag parser if object = nil" do
+      tag_parse("@!scope class")
+      @parser.state.scope.should == :class
+    end
+
+    it "should set state on tag parser if object is namespace" do
+      object = CodeObjects::ClassObject.new(:root, 'Foo')
+      tag_parse("@!scope class", object)
+      object[:scope].should be_nil
+      @parser.state.scope.should == :class
+    end
+
+    it "should set scope on object if object is a method object" do
+      object = CodeObjects::MethodObject.new(:root, 'foo')
+      tag_parse("@!scope class", object)
+      object.scope.should == :class
+    end
+
+    %w(class instance module).each do |type|
+      it "should allow #{type} as value" do
+        tag_parse("@!scope #{type}")
+        @parser.state.scope.should == type.to_sym
+      end
+    end
+
+    %w(invalid foo FOO CLASS INSTANCE).each do |type|
+      it "should not allow #{type} as value" do
+        tag_parse("@!scope #{type}")
+        @parser.state.scope.should be_nil
+      end
+    end
+  end
+end
+
+describe YARD::Tags::VisibilityDirective do
+  describe '#call' do
+    after { Registry.clear }
+
+    it "should set visibility on tag parser if object = nil" do
+      tag_parse("@!visibility private")
+      @parser.state.visibility.should == :private
+    end
+
+    it "should set state on tag parser if object is namespace" do
+      object = CodeObjects::ClassObject.new(:root, 'Foo')
+      tag_parse("@!visibility protected", object)
+      object.visibility.should == :protected
+      @parser.state.visibility.should be_nil
+    end
+
+    it "should set visibility on object if object is a method object" do
+      object = CodeObjects::MethodObject.new(:root, 'foo')
+      tag_parse("@!visibility private", object)
+      object.visibility.should == :private
+    end
+
+    %w(public private protected).each do |type|
+      it "should allow #{type} as value" do
+        tag_parse("@!visibility #{type}")
+        @parser.state.visibility.should == type.to_sym
+      end
+    end
+
+    %w(invalid foo FOO PRIVATE INSTANCE).each do |type|
+      it "should not allow #{type} as value" do
+        tag_parse("@!visibility #{type}")
+        @parser.state.visibility.should be_nil
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/spec/tags/library_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::Library do
+  def tag(docstring)
+    Docstring.new(docstring).tags.first
+  end
+
+  describe '#see_tag' do
+    it "should take a URL" do
+      tag("@see http://example.com").name.should == "http://example.com"
+    end
+
+    it "should take an object path" do
+      tag("@see String#reverse").name.should == "String#reverse"
+    end
+
+    it "should take a description after the url/object" do
+      tag = tag("@see http://example.com An Example Site")
+      tag.name.should == "http://example.com"
+      tag.text.should == "An Example Site"
+    end
+  end
+
+  describe '.define_tag' do
+    it "should allow defining tags with '.' in the name (x.y.z defines method x_y_z)" do
+      Tags::Library.define_tag("foo", 'x.y.z')
+      Tags::Library.define_tag("foo2", 'x.y.zz', Tags::OverloadTag)
+      Tags::Library.instance.method(:x_y_z_tag).should_not be_nil
+      Tags::Library.instance.method(:x_y_zz_tag).should_not be_nil
+      tag('@x.y.z foo bar').text.should == 'foo bar'
+      tag('@x.y.zz foo(bar)').signature.should == 'foo(bar)'
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/spec/tags/overload_tag_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::OverloadTag do
+  before do
+    @tag = Tags::OverloadTag.new(:overload, <<-'eof')
+      def bar(a, b = 1, &block)
+        Hello world
+        @param a [String]
+        @return [String]
+    eof
+  end
+
+  it "should parse the first line as a method signature" do
+    @tag.signature.should == "def bar(a, b = 1, &block)"
+    @tag.parameters.should == [['a', nil], ['b', "1"], ['&block', nil]]
+  end
+
+  it "should parse the rest of the text as a new Docstring" do
+    @tag.docstring.should be_instance_of(Docstring)
+    @tag.docstring.should == "Hello world"
+  end
+
+  it "should set Docstring's object after #object= is called" do
+    m = mock(:object)
+    @tag.object = m
+    @tag.docstring.object.should == m
+  end
+
+  it "should respond to #tag, #tags and #has_tag?" do
+    @tag.object = mock(:object)
+    @tag.tags.size.should == 2
+    @tag.tag(:param).name.should == "a"
+    @tag.has_tag?(:return).should == true
+  end
+
+  it "should not be a CodeObjects::Base when not hooked up to an object" do
+    @tag.object = nil
+    @tag.is_a?(CodeObjects::Base).should == false
+  end
+
+  it "should be a CodeObjects::Base when hooked up to an object" do
+    @tag.object = mock(:object)
+    @tag.object.should_receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
+    @tag.is_a?(CodeObjects::Base).should == true
+    @tag.kind_of?(CodeObjects::Base).should == true
+    (CodeObjects::Base === @tag).should == true
+  end
+
+  it "should not parse 'def' out of method name" do
+    tag = Tags::OverloadTag.new(:overload, "default")
+    tag.signature.should == "default"
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/spec/tags/ref_tag_list_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::RefTagList do
+  before { YARD::Registry.clear }
+
+  it "should accept symbol or string as owner's path and convert it into a proxy" do
+    t = Tags::RefTagList.new('author', :String)
+    t.owner.should == P(:String)
+  end
+
+  it "should accept proxy object as owner" do
+    t = Tags::RefTagList.new('author', P(:String))
+    t.owner.should == P(:String)
+  end
+
+  it "should return tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    t = Tags::Tag.new(:author, 'foo')
+    o.docstring.add_tag(t)
+
+    ref = Tags::RefTagList.new('author', :String)
+    ref.tags.should == [t]
+    ref.tags.first.text.should == 'foo'
+  end
+
+  it "should return named tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+
+    ref = Tags::RefTagList.new('param', :String, 'foo')
+    ref.tags.should == [p1, p2]
+    ref.tags.first.text.should == 'bar1'
+  end
+
+  it "all tags should respond to #owner and be a RefTag" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+
+    ref = Tags::RefTagList.new('param', :String)
+    ref.tags.each do |t|
+      t.should be_kind_of(Tags::RefTag)
+      t.owner.should == o
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/templates/default/tags/html/example.erb

@@ -0,0 +1,11 @@
+<% if object.has_tag?(:example) %>
+  <div class="examples">
+    <p class="tag_title">Examples:</p>
+    <% object.tags(:example).each do |tag| %>
+      <% unless tag.name.empty? %>
+        <p class="example_title"><%= htmlify_line(tag.name) %></p>
+      <% end %>
+      <pre class="example code"><code><%= html_syntax_highlight(tag.text) %></code></pre>
+    <% end %>
+  </div>
+<% end %>

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/templates/default/tags/html/index.erb

@@ -0,0 +1,3 @@
+<div class="tags">
+  <%= yieldall %>
+</div>

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/templates/default/tags/html/option.erb

@@ -0,0 +1,24 @@
+<% if object.has_tag?(:option) %>
+  <% object.parameters.each do |param, default| %>
+    <% tags = object.tags(:option).select {|x| x.name.to_s == param.to_s } %>
+    <% next if tags.empty? %>
+    <p class="tag_title">Options Hash (<tt><%= param %></tt>):</p>
+    <ul class="option">
+      <% for tag in tags %>
+        <li>
+          <span class="name"><%= tag.pair.name %></span>
+          <span class="type"><%= format_types(tag.pair.types || ['Object']) %></span>
+          <span class="default">
+            <% if tag.pair.defaults %>
+              &mdash; default:
+              <%= tag.pair.defaults.map {|t| "<tt>#{h t}</tt>" }.join(", ") %>
+            <% end %>
+          </span>
+          <% if tag.pair.text && tag.pair.text =~ /\S/ %>
+            &mdash; <%= htmlify_line(tag.pair.text) %>
+          <% end %>
+        </li>
+      <% end %>
+    </ul>
+  <% end %>
+<% end %>

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/templates/default/tags/html/overload.erb

@@ -0,0 +1,14 @@
+<% if object.tags(:overload).size == 1 %>
+  <%= yieldall :object => object.tag(:overload) %>
+<% elsif object.has_tag?(:overload) && object.tags(:overload).any? {|o| !o.docstring.blank? } %>
+  <p class="tag_title">Overloads:</p>
+  <ul class="overload">
+    <% object.tags(:overload).each do |overload| %>
+      <% next if overload.docstring.blank? %>
+      <li class="overload_item">
+        <span class="signature"><%= signature(overload, false, false) %></span>
+        <%= yieldall :object => overload %>
+      </li>
+    <% end %>
+  </ul>
+<% end %>

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/templates/default/tags/html/see.erb

@@ -0,0 +1,8 @@
+<% if object.has_tag?(:see) %>
+  <p class="tag_title">See Also:</p>
+  <ul class="see">
+    <% for tag in object.tags(:see) %>
+      <li><%= linkify(tag.name, tag.text) %></li>
+    <% end %>
+  </ul>
+<% end %>

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/templates/default/tags/html/tag.erb

@@ -0,0 +1,20 @@
+<p class="tag_title"><%= @label ? @label : YARD::Tags::Library.labels[@name] %>:</p>
+<ul class="<%= @name %>">
+  <% object.tags(@name).each do |tag| %>
+    <li>
+      <% unless @no_names %>
+        <span class='name'><%= h tag.name %></span>
+      <% end %>
+      <% unless @no_types %>
+        <span class='type'><%= format_types(tag.types) %></span>
+      <% end %>
+      <% if @name == :param && (o=object.parameters.assoc(tag.name.to_s)) && o[1] %>
+        <em class="default">(defaults to: <tt><%= h o[1] %></tt>)</em>
+      <% end %>
+      <% if tag.text && !tag.text.empty? %>
+        <% unless (@no_types || tag.types.nil? || tag.types.empty?) && @no_names %>&mdash;<% end %>
+        <%= htmlify_line(tag.text) %>
+      <% end %>
+    </li>
+  <% end %>
+</ul>