deg-yard 0.8.7.1

data/spec/templates/module_spec.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :module) do
+  before do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module B
+        def c; end
+        def d; end
+        private
+        def e; end
+      end
+
+      module BaseMod
+        attr_reader :base_attr1
+        attr_writer :base_attr2
+        attr_accessor :base_attr3
+      end
+
+      # Comments
+      module A
+        include BaseMod
+        attr_accessor :attr1
+        attr_reader :attr2
+
+        # @overload attr3
+        #   @return [String] a string
+        # @overload attr3=(value)
+        #   @param [String] value sets the string
+        #   @return [void]
+        attr_accessor :attr3
+
+        attr_writer :attr4
+
+        def self.a; end
+        def a; end
+        alias b a
+
+        # @overload test_overload(a)
+        #   hello2
+        #   @param [String] a hi
+        def test_overload(*args) end
+
+        # @overload test_multi_overload(a)
+        # @overload test_multi_overload(a, b)
+        def test_multi_overload(*args) end
+
+        # @return [void]
+        def void_meth; end
+
+        include B
+
+        class Y; end
+        class Q; end
+        class X; end
+        module Z; end
+        # A long docstring for the constant. With extra text
+        # and newlines.
+        CONSTANT = 'value'
+        @@cvar = 'value' # @deprecated
+      end
+
+      module TMP; include A end
+      class TMP2; extend A end
+    eof
+  end
+
+  it "should render html format correctly" do
+    html_equals(Registry.at('A').format(html_options(:hide_void_return => true,
+      :verifier => Verifier.new('object.type != :method || object.visibility == :public'))),
+        :module001)
+  end
+
+  it "should render text format correctly" do
+    YARD.parse_string <<-'eof'
+      module A
+        include D, E, F, A::B::C
+      end
+    eof
+
+    text_equals(Registry.at('A').format(text_options), :module001)
+  end
+
+  it "should render dot format correctly" do
+    Registry.at('A').format(:format => :dot, :dependencies => true, :full => true).should == example_contents(:module001, 'dot')
+  end
+
+  it "should render groups correctly in html" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module A
+        # @group Foo
+        attr_accessor :foo_attr
+        def foo; end
+        def self.bar; end
+
+        # @group Bar
+        def baz; end
+
+        # @endgroup
+
+        def self.baz; end
+      end
+    eof
+
+    html_equals(Registry.at('A').format(html_options), :module002)
+  end
+
+  it "should ignore overwritten/private attributes/constants from inherited list" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module B
+        attr_reader :foo
+        attr_accessor :bar
+        # @private
+        attr_writer :baz
+        FOO = 1
+      end
+      module A
+        include B
+        def foo; end
+        attr_reader :bar
+        FOO = 2
+      end
+    eof
+
+    html_equals(Registry.at('A').format(html_options(
+      :verifier => Verifier.new('!@private'))), :module003)
+  end
+
+  it "should embed mixins with :embed_mixins = ['Foo', 'Bar', 'Baz::A*']" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      class A
+        # This method is in A
+        def foo; end
+
+        include Foo
+        extend Bar
+        include BarFooBar
+        include Baz::XYZ
+        include Baz::ABC
+      end
+
+      module BarFooBar
+        def bar_foo_bar; end
+      end
+
+      module Foo
+        def self.not_included; end
+
+        # Docs for xyz
+        def xyz; end
+        # Docs for bar_attr
+        attr_accessor :bar_attr
+      end
+
+      module Bar
+        def self.not_included; end
+
+        # @group Booya
+
+        # Docs for baz in Booya group
+        def baz; end
+      end
+
+      module Baz
+        module XYZ
+          # listed as inherited
+          def baz_xyz; end
+        end
+
+        module ABC
+          def baz_abc; end
+        end
+      end
+    eof
+
+    html_equals(Registry.at('A').format(html_options(:embed_mixins => ['Foo', 'Bar', 'Baz::A*'])), :module004)
+  end
+end

data/spec/templates/onefile_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class StringSerializer < YARD::Serializers::Base
+  attr_accessor :files, :string
+  def initialize(files, string)
+    @files = files
+    @string = string
+  end
+
+  def serialize(object, data)
+    files << object
+    string << data
+  end
+end
+
+describe YARD::Templates::Engine.template(:default, :onefile) do
+  before do
+    Registry.clear
+    if defined?(::Encoding)
+      @eenc, Encoding.default_external = Encoding.default_external, 'ascii-8bit'
+      @ienc, Encoding.default_internal = Encoding.default_internal, 'ascii-8bit'
+    end
+  end
+
+  after do
+    if defined?(::Encoding)
+      Encoding.default_internal = @ienc
+      Encoding.default_external = @eenc
+    end
+  end
+
+  def render
+    @files = []
+    @output = ''
+    YARD.parse_string <<-eof
+      class A
+        # Foo method
+        # @return [String]
+        def foo; end
+
+        # Bar method
+        # @return [Numeric]
+        def bar; end
+      end
+    eof
+    readme = CodeObjects::ExtraFileObject.new('README',
+      "# This is a code comment\n\n# Top of file\n\n\nclass C; end")
+    Templates::Engine.generate Registry.all(:class),
+      :serializer => StringSerializer.new(@files, @output),
+      :onefile => true, :format => :html, :readme => readme, :files => [readme,
+        CodeObjects::ExtraFileObject.new('LICENSE', 'This is a license!')
+      ]
+  end
+
+  it "should render html" do
+    render
+    @files.should == ['index.html']
+    @output.should include("This is a code comment")
+    @output.should include("This is a license!")
+    @output.should include("Class: A")
+    @output.should include("Foo method")
+    @output.should include("Bar method")
+  end
+end

data/spec/templates/section_spec.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Section do
+  include YARD::Templates
+
+  describe '#initialize' do
+    it "should convert first argument to splat if it is array" do
+      s = Section.new(:name, [:foo, :bar])
+      s.name.should == :name
+      s[0].name.should == :foo
+      s[1].name.should == :bar
+    end
+
+    it "should allow initialization with Section objects" do
+      s = Section.new(:name, [:foo, Section.new(:bar)])
+      s.name.should == :name
+      s[0].should == Section.new(:foo)
+      s[1].should == Section.new(:bar)
+    end
+
+    it "should make a list of sections" do
+      s = Section.new(:name, [:foo, [:bar]])
+      s.should == Section.new(:name, Section.new(:foo, Section.new(:bar)))
+    end
+  end
+
+  describe '#[]' do
+    it "should use Array#[] if argument is integer" do
+      Section.new(:name, [:foo, :bar])[0].name.should == :foo
+    end
+
+    it "should return new Section object if more than one argument" do
+      Section.new(:name, :foo, :bar, :baz)[1, 2].should ==
+        Section.new(:name, :bar, :baz)
+    end
+
+    it "should return new Section object if arg is Range" do
+      Section.new(:name, :foo, :bar, :baz)[1..2].should ==
+        Section.new(:name, :bar, :baz)
+    end
+
+    it "should look for section by name if arg is object" do
+      Section.new(:name, :foo, :bar, [:baz])[:bar][:baz].should ==
+        Section.new(:baz)
+    end
+  end
+
+  describe '#eql?' do
+    it "should check for equality of two equal sections" do
+      Section.new(:foo, [:a, :b]).should be_eql(Section.new(:foo, :a, :b))
+      Section.new(:foo, [:a, :b]).should == Section.new(:foo, :a, :b)
+    end
+
+    it "should not be equal if section names are different" do
+      Section.new(:foo, [:a, :b]).should_not be_eql(Section.new(:bar, :a, :b))
+      Section.new(:foo, [:a, :b]).should_not == Section.new(:bar, :a, :b)
+    end
+  end
+
+  describe '#==' do
+    it "should allow comparison to Symbol" do
+      Section.new(:foo, 2, 3).should == :foo
+    end
+
+    it "should allow comparison to String" do
+      Section.new("foo", 2, 3).should == "foo"
+    end
+
+    it "should allow comparison to Template" do
+      t = YARD::Templates::Engine.template!(:xyzzy, '/full/path/xyzzy')
+      Section.new(t, 2, 3).should == t
+    end
+
+    it "should allow comparison to Section" do
+      Section.new(1, [2, 3]).should == Section.new(1, 2, 3)
+    end
+
+    it "should allow comparison to Object" do
+      Section.new(1, [2, 3]).should == 1
+    end
+
+    it "should allow comparison to Array" do
+      Section.new(1, 2, [3]).should == [1, [2, [3]]]
+    end
+  end
+
+  describe '#to_a' do
+    it "should convert Section to regular Array list" do
+      arr = Section.new(1, 2, [3, [4]]).to_a
+      arr.class.should == Array
+      arr.should == [1, [2, [3, [4]]]]
+    end
+  end
+
+  describe '#place' do
+    it "should place objects as Sections" do
+      Section.new(1, 2, 3).place(4).before(3).should == [1, [2, 4, 3]]
+    end
+
+    it "should place objects anywhere inside Section with before/after_any" do
+      Section.new(1, 2, [3, [4]]).place(5).after_any(4).should == [1, [2, [3, [4, 5]]]]
+      Section.new(1, 2, [3, [4]]).place(5).before_any(4).should == [1, [2, [3, [5, 4]]]]
+    end
+
+    it "should allow multiple sections to be placed" do
+      Section.new(1, 2, 3).place(4, 5).after(3).to_a.should == [1, [2, 3, 4, 5]]
+      Section.new(1, 2, 3).place(4, [5]).after(3).to_a.should == [1, [2, 3, 4, [5]]]
+    end
+  end
+
+  describe '#push' do
+    it "should push objects as Sections" do
+      s = Section.new(:foo)
+      s.push :bar
+      s[0].should == Section.new(:bar)
+    end
+
+    it "should alias to #<<" do
+      s = Section.new(1)
+      s << :index
+      s[:index].should be_a(Section)
+    end
+  end
+
+  describe '#unshift' do
+    it "should unshift objects as Sections" do
+      s = Section.new(:foo)
+      s.unshift :bar
+      s[0].should == Section.new(:bar)
+    end
+  end
+
+  describe '#any' do
+    it "should find item inside sections" do
+      s = Section.new(:foo, Section.new(:bar, Section.new(:bar)))
+      s.any(:bar).push(:baz)
+      s.to_a.should == [:foo, [:bar, [:bar, :baz]]]
+    end
+
+    it "should find item in any deeply nested set of sections" do
+      s = Section.new(:foo, Section.new(:bar, Section.new(:baz)))
+      s.any(:baz).push(:qux)
+      s.to_a.should == [:foo, [:bar, [:baz, [:qux]]]]
+    end
+  end
+end

data/spec/templates/spec_helper.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include YARD::Templates
+
+def only_copy?(result, example, type)
+  if $COPY == :all || $COPY == example
+    puts(result) unless $COPYT && $COPYT != type
+  end
+  $COPY ? true : false
+end
+
+def text_equals(result, expected_example)
+  return if only_copy?(result, expected_example, :text)
+  text_equals_string(result, example_contents(expected_example, :txt))
+end
+
+def text_equals_string(result, expected)
+  result.should == expected
+end
+
+def html_equals(result, expected_example)
+  return if only_copy?(result, expected_example, :html)
+  html_equals_string(result, example_contents(expected_example))
+end
+
+def html_equals_string(result, expected)
+  [expected, result].each do |value|
+    value.gsub!(/(>)\s+|\s+(<)/, '\1\2')
+    value.gsub!(/&#39;/, "'")
+    value.strip!
+  end
+  text_equals_string(result, expected)
+end
+
+def example_contents(filename, ext = 'html')
+  File.read(File.join(File.dirname(__FILE__), 'examples', "#{filename}.#{ext}"))
+end
+
+module YARD::Templates::Engine
+  class << self
+    public :find_template_paths
+  end
+end
+
+class TestHtmlTemplateOptions < Templates::TemplateOptions
+  default_attr :markup, :none
+  default_attr :default_return, ""
+  default_attr :format, :html
+  default_attr :highlight, false
+end
+
+class TestTextTemplateOptions < Templates::TemplateOptions
+  default_attr :markup, :none
+  default_attr :default_return, ""
+  default_attr :format, :text
+  default_attr :highlight, false
+end
+
+def html_options(opts = {})
+  template_options(opts, TestHtmlTemplateOptions)
+end
+
+def text_options(opts = {})
+  template_options(opts, TestTextTemplateOptions)
+end
+
+def template_options(opts, klass)
+  options = klass.new
+  options.reset_defaults
+  options.update(opts)
+  options
+end
+

data/spec/templates/tag_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :tags) do
+  before { Registry.clear }
+
+  describe 'all known tags' do
+    before do
+      YARD.parse_string <<-'eof'
+        # Comments
+        # @abstract override me
+        # @param [Hash] opts the options
+        # @option opts :key ('') hello
+        # @option opts :key2 (X) hello
+        # @return [String] the result
+        # @raise [Exception] Exception class
+        # @deprecated for great justice
+        # @see A
+        # @see http://url.com
+        # @see http://url.com Example
+        # @author Name
+        # @since 1.0
+        # @version 1.0
+        # @yield a block
+        # @yieldparam [String] a a value
+        # @yieldreturn [Hash] a hash
+        # @example Wash your car
+        #   car.wash
+        # @example To kill a mockingbird
+        #   a = String.new
+        #   flip(a.reverse)
+        def m(opts = {}) end
+      eof
+    end
+
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format(text_options), :tag001)
+    end
+  end
+
+  describe 'param tags on non-methods' do
+    it 'should not display @param tags on non-method objects' do
+      YARD.parse_string <<-'eof'
+        # @param [#to_s] name the name
+        module Foo; end
+      eof
+
+      proc = lambda { Registry.at('Foo').format(html_options) }
+      proc.should_not raise_error(NoMethodError)
+    end
+  end
+end