yard 0.2.3.5 → 0.4.0

data/lib/yard/generators/source_generator.rb

@@ -1,11 +0,0 @@
-module YARD
-  module Generators
-    class SourceGenerator < Base
-      include Helpers::MethodHelper
-      
-      def sections_for(object) 
-        [:main] if object.source
-      end
-    end
-  end
-end

data/lib/yard/generators/tags_generator.rb

@@ -1,99 +0,0 @@
-module YARD
-  module Generators
-    class TagsGenerator < Base
-      before_section :header,  :has_tags?
-      before_section :option, :has_options?
-      before_section :param, :has_params?
-      before_section :todo, :has_todo?
-      
-      def sections_for(object)
-        sections = [
-          :header, [ :example, :param, :yield, :yieldparam, :yieldreturn, 
-            :return, :raise, :todo, :author, :version, :since, :see ]
-        ]
-        if object.tags(:overload).size == 1
-          size = sections.last.size
-          sections.last.reverse.each_with_index do |item, index|
-            sections.last[size - index - 1, 1] = [:with_overload, [item]]
-          end
-        end
-        sections
-      end
-      
-      def with_overload(object)
-        yield(object.tag(:overload)) + yield(object)
-      end
-      
-      def yield(object)
-        render_tags :yield
-      end
-      
-      def yieldparam(object)
-        render_tags :yieldparam
-      end
-
-      def yieldreturn(object)
-        render_tags :yieldreturn
-      end
-
-      def return(object)
-        render_tags :return
-      end
-      
-      def raise(object)
-        render_tags :raise, :no_names => true
-      end
-      
-      def author(object)
-        render_tags :author, :no_types => true, :no_names => true
-      end
-
-      def version(object)
-        render_tags :version, :no_types => true, :no_names => true
-      end
-
-      def since(object)
-        render_tags :since, :no_types => true, :no_names => true
-      end
-      
-      protected
-      
-      def has_params?(object)
-        (object.is_a?(Tags::OverloadTag) || 
-        object.is_a?(CodeObjects::MethodObject)) && 
-        tags_by_param(object).size > 0
-      end
-      
-      def has_tags?(object)
-        object.tags.size > 0
-      end
-      
-      def has_todo?(object)
-        object.has_tag?(:todo)
-      end
-      
-      def has_options?(object)
-        object.has_tag?(:option)
-      end
-      
-      def render_tags(name, opts = {})
-        opts = { :name => name }.update(opts)
-        render(current_object, 'tags', opts)
-      end
-      
-      def tags_by_param(object)
-        cache = {}
-        [:param, :option].each do |sym|
-          object.tags(sym).each do |t|
-            cache[t.name.to_s] = t
-          end
-        end
-        
-        object.parameters.map do |p|
-          name = p.first.to_s
-          cache[name] || cache[name[/^[*&](\w+)$/, 1]]
-        end.compact
-      end
-    end
-  end
-end

data/lib/yard/generators/uml_generator.rb

@@ -1,102 +0,0 @@
-module YARD
-  module Generators
-    class UMLGenerator < Base
-      include Helpers::UMLHelper
-      
-      before_generate :init
-      before_section :dependencies, :show_dependencies?
-      
-      def sections_for(object)
-        [
-          :header, 
-          [ 
-            :unknown, [:unresolved, [:unknown_child]],
-            :subgraph, [:info],
-            :superclasses,
-            :dependencies
-          ]
-        ]
-      end
-      
-      def header(object, &block)
-        tidy render(object, :header, &block)
-      end
-      
-      def subgraph(object, &block)
-        name = namespaces(object).empty? ? :child : :subgraph
-        render(object, name, &block)
-      end
-      
-      def unresolved(object, &block)
-        @objects.select {|o| o.is_a?(CodeObjects::Proxy) }.map {|o| yield(o) }.join("\n")
-      end
-      
-      protected
-      
-      def show_full_info?;    options.has_key? :full end
-      def show_dependencies?; options.has_key? :dependencies end
-      
-      def init(object)
-        @objects = {}
-        process_objects(object)
-        @objects = @objects.values
-      end
-      
-      def namespaces(object)
-        object.children.select {|o| o.is_a?(CodeObjects::NamespaceObject) }
-      end
-      
-      def unresolved_objects
-        @direction_paths.values.flatten.select {|o| o.is_a?(CodeObjects::Proxy) }.uniq
-      end
-      
-      def format_path(object)
-        object.path.gsub('::', '_')
-      end
-      
-      def h(text)
-        text.to_s.gsub(/(\W)/, '\\\\\1')
-      end
-      
-      def process_objects(object)
-        @objects[object.path] = object
-        @objects[object.superclass.path] = object.superclass if object.is_a?(CodeObjects::ClassObject) && object.superclass
-        object.mixins.each {|o| @objects[o.path] = o }
-
-        namespaces(object).each {|o| process_objects(o) }
-      end
-      
-      def method_list(object, attributes = false)
-        vissort = lambda {|vis| vis == :public ? 'a' : (vis == :protected ? 'b' : 'c') }
-        
-        meths = object.meths(:inherited => false, :included => false, :visibility => options[:visibility])
-        meths = remove_overriden_meths(object, meths)
-        meths = meths.select {|o| attributes ? o.is_attribute? : !o.is_attribute? }
-        meths = meths.reject {|o| o.is_alias? }
-        meths = meths.sort_by {|o| "#{o.scope}#{vissort.call(o.visibility)}#{o.name}" }
-      end
-      
-      private
-      
-      def remove_overriden_meths(object, meth_list)
-        object.inheritance_tree(true)[1..-1].each do |sclass|
-          next if CodeObjects::Proxy === sclass
-          meth_list.reject! {|o| sclass.child(:scope => o.scope, :name => o.name) }
-        end
-        meth_list
-      end
-      
-      def tidy(data)
-        indent = 0
-        data.split(/\n/).map do |line|
-          line.gsub!(/^\s*/, '')
-          next if line.empty?
-          indent -= 1 if line =~ /^\s*\}\s*$/
-          line = (' ' * (indent * 2)) + line
-          indent += 1 if line =~ /\{\s*$/
-          line
-        end.compact.join("\n") + "\n"
-      end
-    end
-  end
-end

data/lib/yard/generators/visibility_group_generator.rb

@@ -1,26 +0,0 @@
-module YARD
-  module Generators
-    class VisibilityGroupGenerator < Base
-      attr_reader :visibility
-      
-      def initialize(*args)
-        super
-        @visibility = options[:visibility]
-      end
-      
-      before_generate :is_namespace?
-
-      def sections_for(object)
-        [
-          :header,
-          [
-            G(MethodSummaryGenerator, :visibility => visibility, :scope => :class),
-            G(MethodSummaryGenerator, :visibility => visibility, :scope => :instance),
-            G(MethodDetailsGenerator, :visibility => visibility, :scope => :class),
-            G(MethodDetailsGenerator, :visibility => visibility, :scope => :instance)
-          ]
-        ]
-      end
-    end
-  end
-end

data/spec/generators/base_spec.rb

@@ -1,64 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require 'stringio'
-
-include YARD::Generators
-
-describe YARD::Generators::Base, 'Section handling' do
-  before { Registry.clear }
-  
-  it "should allow a list of sections to be returned by sections_for" do
-    base = Generators::Base.new
-    base.stub!(:sections_for).and_return [:meth1, :meth2, :meth3]
-    base.should_receive(:meth1).and_return('a')
-    base.should_receive(:meth2).and_return('b')
-    base.should_receive(:meth3).and_return('c')
-    base.generate(Registry.root).should == 'abc'
-  end
-  
-  it "should allow a heirarchical list of sections to be returned by sections_for" do
-    base = Generators::Base.new
-    base.stub!(:sections_for).and_return [:meth1, [:meth2, :meth3]]
-    base.should_receive(:meth1).and_return('a')
-    base.should_not_receive(:meth2)
-    base.should_not_receive(:meth3)
-    base.generate(Registry.root).should == 'a'
-    base.current_object.should == Registry.root
-  end    
-  
-  it "should yield sub section lists to the parent section" do
-    class XYZ < Generators::Base
-      def sections_for(object) [:meth1, [:submeth1, :submeth2, [:submeth1]]] end
-      def meth1(object) object.name.to_s + yield(object) end
-      def submeth1(object) object.name.to_s end
-      def submeth2(object) object.name.to_s + yield(P(:YARD)) end
-    end
-
-    CodeObjects::Base.new(:root, :YARD)
-    XYZ.new.generate(Registry.root).should == "rootrootrootYARD"
-  end
-end
-
-describe YARD::Generators::Base, 'Rendering' do
-  it "should have a default template path" do
-    Generators::Base.template_paths.should == [YARD::TEMPLATE_ROOT]
-  end
-  
-  it "should find the right erb file to render given a template, format and name" do
-    base = Generators::Base.new
-    file = File.join(YARD::TEMPLATE_ROOT, 'default', 'base', 'html', 'name.erb')
-    File.should_receive(:file?).with(file).and_return(true)
-    File.should_receive(:read).with(file).and_return("output")
-    base.stub!(:sections_for).and_return([:name])
-    base.generate(Registry.root).should == "output"
-  end
-    
-  it "should allow the user to add extra search paths to find a custom template" do
-    Generators::Base.register_template_path 'doc'
-    base = Generators::Base.new
-    file = File.join('doc', 'default', 'base', 'html', 'name.erb')
-    File.should_receive(:file?).with(file).and_return(true)
-    File.should_receive(:read).with(file).and_return("output")
-    base.stub!(:sections_for).and_return([:name])
-    base.generate(Registry.root).should == "output"
-  end
-end

data/spec/generators/full_doc_generator_spec.rb

@@ -1,29 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w|.. spec_helper|)
-
-class YARD::Generators::FullDocGenerator
-  public :generate_files, :readme_file_exists? # public for test
-end
-
-describe YARD::Generators::FullDocGenerator do
-  it "should know about absence of 'readme' file" do
-    generator = Generators::FullDocGenerator.new(:readme => nil)
-    generator.readme_file_exists?.should == false
-  end
-
-  it "should know about existence of 'readme' file" do
-    generator = Generators::FullDocGenerator.new(:readme => __FILE__)
-    generator.readme_file_exists?.should == true
-  end
-
-  it "should allow absence of 'readme' file" do
-    serializer = mock('serializer')
-    generator_options = {
-      :format     => :html,
-      :serializer => serializer,
-      :readme     => nil
-    }
-    generator = Generators::FullDocGenerator.new(generator_options)
-    serializer.should_not_receive(:serialize)
-    lambda { generator.generate_files }.should_not raise_error(Errno::ENOENT)
-  end
-end

data/spec/generators/helpers/base_helper_spec.rb

@@ -1,15 +0,0 @@
-describe YARD::Generators::Helpers::BaseHelper, "#linkify" do
-  include YARD::Generators::Helpers::BaseHelper
-
-  it "should pass off to #link_object if argument is an object" do
-    obj = CodeObjects::NamespaceObject.new(nil, :YARD)
-    should_receive(:link_object).with(obj)
-    linkify obj
-  end
-  
-  it "should pass off to #link_url if argument is recognized as a URL" do
-    url = "http://yard.soen.ca/"
-    should_receive(:link_url).with(url)
-    linkify url
-  end
-end

data/spec/generators/quick_doc_generator_spec.rb

@@ -1,13 +0,0 @@
-describe YARD::Generators::QuickDocGenerator do
-  before { Registry.clear }
-  
-  it "should call all sections" do
-    Parser::SourceParser.parse_string(<<-eof)
-      class A
-        # Docstring
-        def method1; end
-      end
-    eof
-    g = Generators::QuickDocGenerator.new
-  end
-end

data/templates/default/attributes/html/header.erb

@@ -1,47 +0,0 @@
-<div class="section <%= generator_name %>">
-  <h1>Attributes</h1>
-
-  <% ['class', 'instance'].select {|s| object.attributes[s].length > 0 }.each do |scope| %>
-    <div class="<%= scope %>">
-      <h2><%= scope.capitalize %> Attributes</h2>
-      <table>
-      <% object.attributes[scope].sort_by {|o| o.to_s.downcase }.each do |name, rw| %>
-        <% aliases = (rw[:read] || rw[:write]).aliases %>
-        <tr class="<%= 'hasaliases' if aliases.length > 0 %>">
-          <th class='signature'>
-            <span class='name'><%= h name %></span>
-          </td>
-          <td class="readwrite">
-            [<%= ['read', 'write'].map {|t| 
-                rw[t] && (rw[t].is_explicit? ? t[0,1].upcase : "<span id='#{anchor_for rw[t]}'>#{t[0,1].upcase}</span>")
-              }.compact.join %>] 
-          </td>
-          <td class="visibility">
-            <%= rw.values.compact.first.visibility %>
-          </td>
-          <td class="docstring">
-            <%= htmlify rw.values.compact.first.docstring.summary %>
-            <% if rw[:read] && rw[:read].tag(:return) && rw[:read].tag(:return).types %>
-              <p class='returns'>
-                Returns: 
-                  <span class='return_types'>
-                     <%= format_return_types rw[:read] %>
-                  </span>
-              </p>
-            <% end %>
-          </td>
-        </tr>
-        <% if aliases.length > 0 %>
-          <tr>
-            <td colspan='4' class='aliases'><span class='text'>Also known as:</span>
-              <% aliases.each_with_index do |obj, i| %>
-                <span class='alias'><%= h obj.name.to_s.sub(/=$/, '') %></span><%= "," if i < aliases.length - 1 %>
-              <% end %>
-            </td>
-          </tr>
-        <% end %>
-      <% end %>
-      </table>
-    </div>
-  <% end %>
-</div>

data/templates/default/attributes/text/header.erb

@@ -1,10 +0,0 @@
-
-
-> Attributes:
--------------
-<% ['class', 'instance'].select {|s| object.attributes[s].length > 0 }.each do |scope| %>
-<% object.attributes[scope].sort_by {|o| o.to_s.downcase }.each do |name, rw| %>
-<%= uml_visibility rw.values.compact.first %> <%= name %><%= " " if scope == 'class' %>	[<%= ['read', 'write'].map {|t| rw[t] ? t[0,1].upcase : ' ' }.compact.join %>]	(<%= rw.values.compact.first.visibility %>)
-<% end %>
-<% end %>
-

data/templates/default/class/html/header.erb

@@ -1,4 +0,0 @@
-<div class="section class <%= object.path.gsub(/::|\.|#/, '_') %>">
-  <h1 class="title"><%= h format_object_type(object) %>: <%= h object.path %></h1>
-  <%= yield object %>
-</div>

data/templates/default/constants/html/constants.erb

@@ -1,9 +0,0 @@
-<div class="thisclass">
-  <h1>Constants</h1>
-  <dl>
-    <% object.constants(:included => false, :inherited => false).sort_by {|c| c.name.to_s.downcase }.each do |const| %>
-      <dt id="<%= anchor_for(const) %>"><%= h const.name %></dt>
-      <dd><%= h const.source.gsub(/\A.+?\=\s*/, '') %></dd>
-    <% end %>
-  </dl>
-</div>

data/templates/default/constants/html/header.erb

@@ -1,3 +0,0 @@
-<div class="section <%= generator_name %>">
-  <%= yield object %>
-</div>