yard 0.2.3.5 → 0.4.0

data/lib/yard/generators/helpers/html_syntax_highlight_helper.rb

@@ -1,49 +0,0 @@
-module YARD
-  module Generators
-    module Helpers
-      module HtmlSyntaxHighlightHelper
-        def html_syntax_highlight(source)
-          tokenlist = Parser::Ruby::RubyParser.parse(source, "(syntax_highlight)").tokens
-          output = ""
-          tokenlist.each do |s|
-            output << "<span class='tstring'>" if [:tstring_beg, :regexp_beg].include?(s[0])
-            case s.first
-            when :nl, :ignored_nl, :sp
-              output << h(s.last)
-            when :ident
-              output << "<span class='id #{h(s.last)}'>#{h(s.last)}</span>"
-            else
-              output << "<span class='#{s.first}'>#{h(s.last)}</span>"
-            end
-            output << "</span>" if [:tstring_end, :regexp_end].include?(s[0])
-          end
-          output
-        rescue Parser::ParserSyntaxError
-          source
-        end
-
-        def html_syntax_highlight_legacy(source)
-          tokenlist = Parser::Ruby::Legacy::TokenList.new(source)
-          tokenlist.map do |s| 
-            prettyclass = s.class.class_name.sub(/^Tk/, '').downcase
-            prettysuper = s.class.superclass.class_name.sub(/^Tk/, '').downcase
-
-            case s
-            when Parser::Ruby::Legacy::RubyToken::TkWhitespace, Parser::Ruby::Legacy::RubyToken::TkUnknownChar
-              h s.text
-            when Parser::Ruby::Legacy::RubyToken::TkId
-              prettyval = h(s.text)
-              "<span class='#{prettyval} #{prettyclass} #{prettysuper}'>#{prettyval}</span>"
-            else
-              "<span class='#{prettyclass} #{prettysuper}'>#{h s.text}</span>"
-            end
-          end.join
-        end
-        
-        if RUBY18
-          alias html_syntax_highlight html_syntax_highlight_legacy
-        end
-      end
-    end
-  end
-end

data/lib/yard/generators/helpers/uml_helper.rb

@@ -1,16 +0,0 @@
-module YARD
-  module Generators::Helpers
-    module UMLHelper
-      def uml_visibility(object)
-        case object.visibility
-        when :public
-          '+'
-        when :protected
-          '#'
-        when :private
-          '-'
-        end
-      end
-    end
-  end
-end

data/lib/yard/generators/inheritance_generator.rb

@@ -1,16 +0,0 @@
-module YARD
-  module Generators
-    class InheritanceGenerator < Base
-      before_generate :has_inheritance_tree?
-      
-      def sections_for(object) [:header] end
-        
-      protected
-      
-      def has_inheritance_tree?(object)
-        return false unless object.is_a?(CodeObjects::ClassObject)
-        object.inheritance_tree.size > 1
-      end
-    end
-  end
-end

data/lib/yard/generators/method_details_generator.rb

@@ -1,18 +0,0 @@
-module YARD
-  module Generators
-    class MethodDetailsGenerator < MethodListingGenerator
-      before_generate :is_namespace?
-      before_generate :has_methods?
-
-      def sections_for(object)
-        [
-          :header, 
-          [ # with MethodObject
-            :method_header,
-            G(MethodGenerator),
-          ]
-        ]
-      end
-    end
-  end
-end

data/lib/yard/generators/method_generator.rb

@@ -1,43 +0,0 @@
-module YARD
-  module Generators
-    class MethodGenerator < Base
-      include Helpers::MethodHelper
-
-      before_generate :is_method?
-      before_section :aliases, :has_aliases?
-      before_section :source, :isnt_overload?
-      
-      def sections_for(object) 
-        [
-          :header,
-          [
-            :title,
-            [
-              G(MethodSignatureGenerator), 
-              :aliases
-            ], 
-            G(DeprecatedGenerator), 
-            G(DocstringGenerator), 
-            G(TagsGenerator), 
-            G(OverloadsGenerator),
-            :source
-          ]
-        ]
-      end
-      
-      protected
-
-      def source(object)
-        render_section(G(SourceGenerator), object)
-      end
-
-      def has_aliases?(object)
-        !object.aliases.empty?
-      end
-
-      def isnt_overload?(object)
-        !object.is_a?(Tags::OverloadTag)
-      end
-    end
-  end
-end

data/lib/yard/generators/method_listing_generator.rb

@@ -1,105 +0,0 @@
-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(scope).each do |mixin|
-          next if mixin.is_a?(CodeObjects::Proxy)
-          meths = mixin.meths(meths_opts.merge(:scope => :instance)).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

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

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

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

@@ -1,21 +0,0 @@
-module YARD
-  module Generators
-    class MixinsGenerator < Base
-      attr_reader :scope
-      before_generate :has_mixins?
-
-      def initialize(*args)
-        super
-        @scope = options[:scope]
-      end
-      
-      def sections_for(object) [:header] end
-        
-      protected
-      
-      def has_mixins?(object)
-        !object.mixins(@scope).empty?
-      end
-    end
-  end
-end

data/lib/yard/generators/module_generator.rb

@@ -1,23 +0,0 @@
-module YARD
-  module Generators
-    class ModuleGenerator < Base
-      before_generate :is_module?
-      
-      def sections_for(object) 
-        [
-          :header,
-          [
-            G(MixinsGenerator, :scope => :class),
-            G(MixinsGenerator, :scope => :instance),
-            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/overloads_generator.rb

@@ -1,20 +0,0 @@
-module YARD
-  module Generators
-    class OverloadsGenerator < Base
-      before_generate :has_overloads?
-
-      def sections_for(object)
-        [
-          :header,
-          [G(MethodGenerator)]
-        ]
-      end
-
-      protected
-
-      def has_overloads?(object)
-        object.tags(:overload).size > 1
-      end
-    end
-  end
-end

data/lib/yard/generators/quick_doc_generator.rb

@@ -1,25 +0,0 @@
-module YARD
-  module Generators
-    class QuickDocGenerator < Base
-      def sections_for(object)
-        case object
-        when CodeObjects::MethodObject
-          [
-            :header,
-            [G(MethodGenerator)]
-          ]
-        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/root_generator.rb

@@ -1,32 +0,0 @@
-module YARD
-  module Generators
-    class RootGenerator < Base
-      before_generate :is_root?
-      before_generate :has_data?
-      
-      def sections_for(object) 
-        [
-          :header,
-          [
-            G(MixinsGenerator, :scope => :class),
-            G(MixinsGenerator, :scope => :instance),
-            G(ConstantsGenerator),
-            G(VisibilityGroupGenerator, :visibility => :public),
-            G(VisibilityGroupGenerator, :visibility => :protected),
-            G(VisibilityGroupGenerator, :visibility => :private)
-          ]
-        ]
-      end
-      
-      private
-      
-      def has_data?(object)
-        object.meths.size > 0 || object.constants.size > 0
-      end
-      
-      def is_root?(object)
-        object == Registry.root
-      end
-    end
-  end
-end