yard 0.2.1 → 0.2.2

data/lib/yard/generators/method_listing_generator.rb

@@ -0,0 +1,105 @@
+module YARD
+  module Generators
+    class MethodListingGenerator < Base
+      include Helpers::MethodHelper
+
+      attr_reader :scope, :visibility
+      
+      def initialize(*args)
+        super
+        @scope = options[:scope]
+        @visibility = options[:visibility]
+      end
+      
+      protected
+      
+      def has_methods?(object)
+        method_list.size > 0
+      end
+      
+      def has_inherited_methods?(object)
+        return false unless object.is_a?(CodeObjects::ClassObject)
+        meths = object.inherited_meths(:scope => scope, :visibility => visibility)
+        remove_ignored_meths!(meths)
+        meths.size > 0
+      end
+
+      def has_included_methods?(object)
+        meths = object.included_meths(:scope => scope, :visibility => visibility)
+        remove_ignored_meths!(meths, false)
+        meths.size > 0
+      end
+      
+      def method_list
+        meths = current_object.meths(meths_opts)
+        remove_ignored_meths!(meths)
+        meths.sort_by {|m| m.name.to_s.downcase }
+      end
+      
+      # @yield [superclass, meths] 
+      #   Yields a the list of methods pertaining to a superclass
+      #   in the inheritance order.
+      # 
+      # @yieldparam [CodeObjects::ClassObject] superclass 
+      #   The superclass the methods belong to
+      # 
+      # @yieldparam [Array<CodeObjects::ConstantObject>] meths
+      #   The list of methods inherited from the superclass
+      # 
+      def inherited_meths_by_class
+        all_meths = current_object.inherited_meths(:scope => scope, :visibility => visibility)
+        current_object.inheritance_tree[1..-1].each do |superclass|
+          next if superclass.is_a?(CodeObjects::Proxy)
+          meths = superclass.meths(meths_opts).select {|c| all_meths.include?(c) }
+          remove_ignored_meths!(meths)
+          next if meths.empty?
+          yield(superclass, meths)
+        end
+      end
+
+      # @yield [mixin, meths] 
+      #   Yields a the list of methods pertaining to a module
+      #   in the module order.
+      # 
+      # @yieldparam [CodeObjects::ModuleObject] mixin 
+      #   The module the methods belong to
+      # 
+      # @yieldparam [Array<CodeObjects::ConstantObject>] meths
+      #   The list of methods included from the module
+      # 
+      def included_meths_by_module
+        all_meths = current_object.included_meths(:scope => scope, :visibility => visibility)
+        current_object.mixins.each do |mixin|
+          next if mixin.is_a?(CodeObjects::Proxy)
+          meths = mixin.meths(meths_opts).select {|c| all_meths.include?(c) }
+          remove_ignored_meths!(meths)
+          next if meths.empty?
+          yield(mixin, meths)
+        end
+      end
+      
+      def ignored_meths
+        { 
+          :instance => [:initialize, :method_missing], 
+          :class => [:new] 
+        }
+      end
+      
+      def remove_ignored_meths!(list, explicit_attr = true)
+        list.reject! do |o| 
+          ignored_meths[o.scope].include?(o.name) || 
+            o.is_alias? || (explicit_attr ? (o.is_attribute? && !o.is_explicit?) : o.is_attribute?)
+        end
+      end
+      
+      private
+      
+      def meths_opts
+        { 
+          :included => false, :inherited => false,
+          :scope => scope, :visibility => visibility 
+        }
+      end
+    end
+  end
+end

data/lib/yard/generators/method_missing_generator.rb

@@ -0,0 +1,25 @@
+module YARD
+  module Generators
+    class MethodMissingGenerator < Base
+      before_generate :has_method_missing?
+       
+      def sections_for(object) 
+        [:header, [G(MethodGenerator)]] 
+      end
+      
+      protected
+      
+      def has_method_missing?
+        method_missing_method ? true : false 
+      end
+      
+      def method_missing_method
+        current_object.meths.find {|o| o.name == :method_missing && o.scope == :instance }
+      end
+      
+      def method_missing_method_inherited?
+        method_missing_method.namespace != current_object
+      end
+    end
+  end
+end

data/lib/yard/generators/method_signature_generator.rb

@@ -0,0 +1,19 @@
+module YARD
+  module Generators
+    class MethodSignatureGenerator < Base
+      include Helpers::MethodHelper
+
+      before_generate :has_signature?
+      
+      def sections_for(object) 
+        [:main] 
+      end
+      
+      protected
+      
+      def has_signature?(object)
+        object.signature ? true : false
+      end
+    end
+  end
+end

data/lib/yard/generators/method_summary_generator.rb

@@ -0,0 +1,21 @@
+module YARD
+  module Generators
+    class MethodSummaryGenerator < MethodListingGenerator
+      before_generate :is_namespace?
+      before_section  :summary,   :has_methods?
+      before_section  :inherited, :has_inherited_methods?
+      before_section  :included,  :has_included_methods?
+      
+      def sections_for(object)
+        [
+          :header, 
+          [
+            :summary,
+            :inherited,
+            :included
+          ]
+        ]
+      end
+    end
+  end
+end

data/lib/yard/generators/mixins_generator.rb

@@ -0,0 +1,15 @@
+module YARD
+  module Generators
+    class MixinsGenerator < Base
+      before_generate :has_mixins?
+      
+      def sections_for(object) [:header] end
+        
+      protected
+      
+      def has_mixins?(object)
+        !object.mixins.empty?
+      end
+    end
+  end
+end

data/lib/yard/generators/module_generator.rb

@@ -0,0 +1,22 @@
+module YARD
+  module Generators
+    class ModuleGenerator < Base
+      before_generate :is_module?
+      
+      def sections_for(object) 
+        [
+          :header,
+          [
+            G(MixinsGenerator), 
+            G(DocstringGenerator), 
+            G(AttributesGenerator), 
+            G(ConstantsGenerator),
+            G(VisibilityGroupGenerator, :visibility => :public),
+            G(VisibilityGroupGenerator, :visibility => :protected),
+            G(VisibilityGroupGenerator, :visibility => :private)
+          ]
+        ]
+      end
+    end
+  end
+end

data/lib/yard/generators/quick_doc_generator.rb

@@ -0,0 +1,31 @@
+module YARD
+  module Generators
+    class QuickDocGenerator < Base
+      def sections_for(object)
+        case object
+        when CodeObjects::MethodObject
+          [
+            :header, 
+            [
+              G(DeprecatedGenerator), 
+              G(DocstringGenerator), 
+              G(MethodSignatureGenerator), 
+              G(TagsGenerator), 
+              G(SourceGenerator)
+            ]
+          ]
+        when CodeObjects::NamespaceObject
+          [
+            :header, 
+            [
+              G(DeprecatedGenerator), 
+              G(DocstringGenerator),
+              G(AttributesGenerator),
+              G(MethodSummaryGenerator, :scope => [:class, :instance], :visibility => :public)
+            ]
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/yard/generators/source_generator.rb

@@ -0,0 +1,26 @@
+module YARD
+  module Generators
+    class SourceGenerator < Base
+      def sections_for(object) 
+        [:main] if object.source
+      end
+      
+      protected
+      
+      def format_lines(object)
+        i = -1
+        object.source.split(/\n/).map { object.line + (i += 1) }.join("\n")
+      end
+      
+      def format_code(object, show_lines = false)
+        i = -1
+        lines = object.source.split(/\n/)
+        longestline = (object.line + lines.size).to_s.length
+        lines.map do |line| 
+          lineno = object.line + (i += 1)
+          (" " * (longestline - lineno.to_s.length)) + lineno.to_s + "    " + line
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/yard/generators/tags_generator.rb

@@ -0,0 +1,50 @@
+module YARD
+  module Generators
+    class TagsGenerator < Base
+      before_section :header, :has_tags?
+      
+      def sections_for(object)
+        [:header, [:param, :yieldparam, :return, :raise, :author, :version, :since, :see]]
+      end
+      
+      def param(object)
+        render_tags :param
+      end
+      
+      def yieldparam(object)
+        render_tags :yieldparam
+      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_tags?(object)
+        object.tags.size > 0
+      end
+      
+      def render_tags(name, opts = {})
+        opts = { :name => name }.update(opts)
+        render(current_object, 'tags', opts)
+      end
+    end
+  end
+end

data/lib/yard/generators/uml_generator.rb

@@ -0,0 +1,92 @@
+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.mixins.each {|o| @objects[o.path] = o }
+
+        namespaces(object).each {|o| process_objects(o) }
+      end
+      
+      def method_list(object)
+        vissort = lambda {|vis| vis == :public ? 'a' : (vis == :protected ? 'b' : 'c') }
+        
+        object.meths(:inherited => false, :included => false, :visibility => options[:visibility]).reject do |o|
+          o.is_attribute?
+        end.sort_by {|o| "#{o.scope}#{vissort.call(o.visibility)}#{o.name}" }
+      end
+      
+      private
+      
+      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

@@ -0,0 +1,26 @@
+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