sidekiq-statsd 0.1.0 → 0.1.1

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/lib/yard/tags/overload_tag.rb

@@ -0,0 +1,65 @@
+module YARD
+  module Tags
+    class OverloadTag < Tag
+      attr_reader :signature, :parameters, :docstring
+
+      def initialize(tag_name, text)
+        super(tag_name, nil)
+        parse_tag(text)
+        parse_signature
+      end
+
+      def tag(name) docstring.tag(name) end
+      def tags(name = nil) docstring.tags(name) end
+      def has_tag?(name) docstring.has_tag?(name) end
+
+      def object=(value)
+        super(value)
+        docstring.object = value
+      end
+
+      def name(prefix = false)
+        return @name unless prefix
+        object.scope == :class ? @name.to_s : "#{object.send(:sep)}#{@name}"
+      end
+
+      def method_missing(*args, &block)
+        object.send(*args, &block)
+      end
+
+      def type
+        object.type
+      end
+
+      def is_a?(other)
+        object.is_a?(other) || self.class >= other.class || false
+      end
+      alias kind_of? is_a?
+
+      private
+
+      def parse_tag(text)
+        @signature, text = *text.split(/\r?\n/, 2)
+        @signature.strip!
+        text ||= ""
+        numspaces = text[/\A(\s*)/, 1].length
+        text.gsub!(/^[ \t]{#{numspaces}}/, '')
+        text.strip!
+        @docstring = Docstring.new(text, nil)
+      end
+
+      def parse_signature
+        if signature =~ /^(?:def\s)?\s*(#{CodeObjects::METHODMATCH})(?:(?:\s+|\s*\()(.*)(?:\)\s*$)?)?/m
+          meth, args = $1, $2
+          meth.gsub!(/\s+/,'')
+          # FIXME refactor this code to not make use of the Handlers::Base class (tokval_list should be moved)
+          toks = YARD::Parser::Ruby::Legacy::TokenList.new(args)
+          args = YARD::Handlers::Ruby::Legacy::Base.new(nil, nil).send(:tokval_list, toks, :all)
+          args.map! {|a| k, v = *a.split('=', 2); [k.strip.to_s, (v ? v.strip : nil)] } if args
+          @name = meth.to_sym
+          @parameters = args
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/lib/yard/tags/ref_tag.rb

@@ -0,0 +1,7 @@
+module YARD
+  module Tags
+    module RefTag
+      attr_accessor :owner
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/lib/yard/tags/ref_tag_list.rb

@@ -0,0 +1,27 @@
+module YARD
+  module Tags
+    class RefTagList
+      attr_accessor :owner, :tag_name, :name
+
+      def initialize(tag_name, owner, name = nil)
+        @owner = CodeObjects::Proxy === owner ? owner : P(owner)
+        @tag_name = tag_name.to_s
+        @name = name
+      end
+
+      def tags
+        if owner.is_a?(CodeObjects::Base)
+          o = owner.tags(tag_name)
+          o = o.select {|t| t.name.to_s == name.to_s } if name
+          o.each do |t|
+            t.extend(RefTag)
+            t.owner = owner
+          end
+          o
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/lib/yard/tags/tag.rb

@@ -0,0 +1,57 @@
+module YARD
+  module Tags
+    # Represents a metadata tag value (+@tag+). Tags can have any combination of
+    # {#types}, {#name} and {#text}, or none of the above.
+    #
+    # @example Programmatic tag creation
+    #   # The following docstring syntax:
+    #   #   @param [String, nil] arg an argument
+    #   #
+    #   # is equivalent to:
+    #   Tag.new(:param, 'an argument', ['String', 'nil'], 'arg')
+    class Tag
+      # @return [String] the name of the tag
+      attr_accessor :tag_name
+
+      # @return [String] the tag text associated with the tag
+      # @return [nil] if no tag text is supplied
+      attr_accessor :text
+
+      # @return [Array<String>] a list of types associated with the tag
+      # @return [nil] if no types are associated with the tag
+      attr_accessor :types
+
+      # @return [String] a name associated with the tag
+      attr_accessor :name
+
+      # @return [CodeObjects::Base] the associated object
+      attr_accessor :object
+
+      # Creates a new tag object with a tag name and text. Optionally, formally declared types
+      # and a key name can be specified.
+      #
+      # Types are mainly for meta tags that rely on type information, such as +param+, +return+, etc.
+      #
+      # Key names are for tags that declare meta data for a specific key or name, such as +param+,
+      # +raise+, etc.
+      #
+      # @param [#to_s] tag_name        the tag name to create the tag for
+      # @param [String] text           the descriptive text for this tag
+      # @param [Array<String>] types   optional type list of formally declared types
+      #                                for the tag
+      # @param [String] name           optional key name which the tag refers to
+      def initialize(tag_name, text, types = nil, name = nil)
+        @tag_name, @text, @name, @types = tag_name.to_s, text, name, (types ? [types].flatten.compact : nil)
+      end
+
+      # Convenience method to access the first type specified. This should mainly
+      # be used for tags that only specify one type.
+      #
+      # @return [String] the first of the list of specified types
+      # @see #types
+      def type
+        types.first
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/yard-0.8.6.1/lib/yard/tags/tag_format_error.rb

@@ -0,0 +1,6 @@
+module YARD
+  module Tags
+    class TagFormatError < Exception
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::DefaultFactory do
+  before { @f = YARD::Tags::DefaultFactory.new }
+
+  describe '#parse_tag' do
+    it "should not have trailing whitespace on a regular freeform tag" do
+      @f.parse_tag('api', 'private     ').text.should == "private"
+    end
+  end
+
+  describe '#extract_types_and_name_from_text' do
+    def parse_types(types)
+      @f.send(:extract_types_and_name_from_text, types)
+    end
+
+    it "should handle one type" do
+      parse_types('[A]').should == [nil, ['A'], ""]
+    end
+
+    it "should handle a list of types" do
+      parse_types('[A, B, C]').should == [nil, ['A', 'B', 'C'], ""]
+    end
+
+    it "should handle ducktypes" do
+      parse_types('[#foo]').should == [nil, ['#foo'], '']
+    end
+
+    %w(#foo= #<< #<=> #>> #== #=== Array<#<=>> Array<#==>).each do |meth|
+      it "should handle ducktypes with special method name #{meth}" do
+        parse_types("[#{meth}]").should == [nil, [meth], '']
+      end
+    end
+
+    it "should only parse #ducktypes inside brackets" do
+      parse_types("#ducktype").should == [nil, nil, '#ducktype']
+    end
+
+    it "should return the text before and after the type list" do
+      parse_types(' b <String> description').should == ['b', ['String'], 'description']
+      parse_types('b c <String> description (test)').should == [nil, nil, 'b c <String> description (test)']
+    end
+
+    it "should handle a complex list of types" do
+      v = parse_types(' [Test, Array<String, Hash, C>, String]')
+      v.should include(["Test", "Array<String, Hash, C>", "String"])
+    end
+
+    it "should handle any of the following start/end delimiting chars: (), <>, {}, []" do
+      a = parse_types('[a,b,c]')
+      b = parse_types('<a,b,c>')
+      c = parse_types('(a,b,c)')
+      d = parse_types('{a,b,c}')
+      a.should == b
+      b.should == c
+      c.should == d
+      a.should include(['a','b','c'])
+    end
+
+    it "should return the text before the type list as the last element" do
+      parse_types('b[x, y, z]').should == ['b', ['x', 'y', 'z'], '']
+      parse_types('  ! <x>').should == ["!", ['x'], '']
+    end
+
+    it "should return text unparsed if there is no type list" do
+      parse_types('').should == [nil, nil, '']
+      parse_types('[]').should == [nil, nil, '[]']
+    end
+
+    it "should allow A => B syntax" do
+      v = parse_types(' [Test, Array<String, Hash{A => {B => C}}, C>, String]')
+      v.should include(["Test", "Array<String, Hash{A => {B => C}}, C>", "String"])
+    end
+  end
+
+  describe '#parse_tag_with_types' do
+    def parse_types(text)
+      @f.send(:parse_tag_with_types, 'test', text)
+    end
+
+    it "should parse given types and description" do
+      YARD::Tags::Tag.should_receive(:new).with("test", "description", ["x", "y", "z"])
+      parse_types(' [x, y, z] description')
+    end
+
+    it "should parse given types only" do
+      YARD::Tags::Tag.should_receive(:new).with("test", "", ["x", "y", "z"])
+      parse_types(' [x, y, z] ')
+    end
+
+    it "should allow type list to be omitted" do
+      YARD::Tags::Tag.should_receive(:new).with('test', 'description', nil)
+      parse_types('  description    ')
+    end
+
+    it "should raise an error if a name is specified before type list" do
+      lambda { parse_types('b<String> desc') }.should raise_error(YARD::Tags::TagFormatError, 'cannot specify a name before type list for \'@test\'')
+    end
+  end
+
+  describe '#parse_tag_with_types_name_and_default' do
+    def parse_types(text)
+      @f.send(:parse_tag_with_types_name_and_default, 'test', text)
+    end
+
+    it "should parse a standard type list with name before types (no default)" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
+      parse_types('NAME [x, y, z] description')
+    end
+
+    it "should parse a standard type list with name after types (no default)" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
+      parse_types('  [x, y, z] NAME description')
+    end
+
+    it "should parse a tag definition with name, typelist and default" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
+      parse_types('  [x, y, z] NAME (default, values) description')
+    end
+
+    it "should parse a tag definition with name, typelist and default when name is before type list" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
+      parse_types(' NAME [x, y, z] (default, values) description')
+    end
+
+    it "should allow typelist to be omitted" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", nil, 'NAME', ['default', 'values'])
+      parse_types('  NAME (default, values) description')
+    end
+  end
+
+  describe '#parse_tag_with_options' do
+    def parse_options(text)
+      @f.parse_tag_with_options('option', text)
+    end
+
+    it "should have a name before tag info" do
+      t = parse_options("xyz key [Types] (default) description")
+      t.tag_name.should == 'option'
+      t.name.should == 'xyz'
+    end
+
+    it "should parse the rest of the tag like DefaultTag" do
+      t = parse_options("xyz key [Types] (default) description")
+      t.pair.should be_instance_of(Tags::DefaultTag)
+      t.pair.types.should == ["Types"]
+      t.pair.name.should == "key"
+      t.pair.defaults.should == ["default"]
+      t.pair.text.should == "description"
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::DefaultTag do
+  it "should create a tag with defaults" do
+    o = YARD::Tags::DefaultTag.new('tagname', 'desc', ['types'], 'name', ['defaults'])
+    o.defaults.should == ['defaults']
+    o.tag_name.should == 'tagname'
+    o.name.should == 'name'
+    o.types.should == ['types']
+  end
+end