yard 0.2.3.5 → 0.4.0

data/lib/yard/generators/class_generator.rb

@@ -1,27 +0,0 @@
-module YARD
-  module Generators
-    class ClassGenerator < Base
-      before_generate :is_class?
-      
-      def sections_for(object) 
-        [
-          :header,
-          [
-            G(InheritanceGenerator), 
-            G(MixinsGenerator, :scope => :class),
-            G(MixinsGenerator, :scope => :instance),
-            G(DocstringGenerator), 
-            G(TagsGenerator),
-            G(AttributesGenerator), 
-            G(ConstantsGenerator),
-            G(ConstructorGenerator),
-            G(MethodMissingGenerator),
-            G(VisibilityGroupGenerator, :visibility => :public),
-            G(VisibilityGroupGenerator, :visibility => :protected),
-            G(VisibilityGroupGenerator, :visibility => :private)
-          ]
-        ]
-      end
-    end
-  end
-end

data/lib/yard/generators/constants_generator.rb

@@ -1,74 +0,0 @@
-module YARD
-  module Generators
-    class ConstantsGenerator < Base
-      before_generate :is_namespace?
-      before_section :constants, :has_constants?
-      before_section :inherited, :has_inherited_constants?
-      before_section :included,  :has_included_constants?
-      
-      def sections_for(object) 
-        if object.is_a?(CodeObjects::ClassObject)
-          [:header, [:constants, :inherited, :included]] 
-        elsif object.is_a?(CodeObjects::ModuleObject)
-          [:header, [:constants]]
-        end
-      end
-
-      protected
-      
-      def has_constants?(object)
-        object.constants(:included => false, :inherited => false).size > 0
-      end
-      
-      def has_inherited_constants?(object)
-        return false unless object.is_a?(CodeObjects::ClassObject)
-        object.inherited_constants.size > 0
-      end
-      
-      def has_included_constants?(object)
-        object.included_constants.size > 0
-      end
-        
-      # @yield a the list of methods pertaining to a superclass
-      #   in the inheritance order.
-      # 
-      # @yieldparam [CodeObjects::ClassObject] superclass 
-      #   The superclass the constants belong to
-      # 
-      # @yieldparam [Array<CodeObjects::ConstantObject>] consts
-      #   The list of constants inherited from the superclass
-      # 
-      def inherited_constants_by_class
-        all_consts = current_object.inherited_constants
-        current_object.inheritance_tree[1..-1].each do |superclass|
-          next if superclass.is_a?(CodeObjects::Proxy)
-          opts = { :included => false, :inherited => false }
-          consts = superclass.constants(opts).select {|c| all_consts.include?(c) }
-          next if consts.empty?
-          yield(superclass, consts)
-        end
-      end
-
-      # @yield [module, constlist] 
-      #   Yields a the list of methods pertaining to a module
-      #   in the module order.
-      # 
-      # @yieldparam [CodeObjects::ModuleObject] module 
-      #   The module the constants belong to
-      # 
-      # @yieldparam [Array<CodeObjects::ConstantObject>] consts
-      #   The list of constants included from the module
-      # 
-      def included_constants_by_module
-        all_consts = current_object.included_constants
-        current_object.instance_mixins.each do |superclass|
-          next if superclass.is_a?(CodeObjects::Proxy)
-          opts = { :included => false, :inherited => false }
-          consts = superclass.constants(opts).select {|c| all_consts.include?(c) }
-          next if consts.empty?
-          yield(superclass, consts)
-        end
-      end
-    end
-  end
-end

data/lib/yard/generators/constructor_generator.rb

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

data/lib/yard/generators/deprecated_generator.rb

@@ -1,15 +0,0 @@
-module YARD
-  module Generators
-    class DeprecatedGenerator < Base
-      before_generate :is_deprecated?
-      
-      def sections_for(object) [:main] end
-        
-      protected
-      
-      def is_deprecated?(object)
-        object.tag(:deprecated) ? true : false
-      end
-    end
-  end
-end

data/lib/yard/generators/docstring_generator.rb

@@ -1,15 +0,0 @@
-module YARD
-  module Generators
-    class DocstringGenerator < Base
-      before_section :main, :has_docstring?
-      
-      def sections_for(object) [:main] end
-      
-      protected
-      
-      def has_docstring?
-        !current_object.docstring.empty?
-      end
-    end
-  end
-end

data/lib/yard/generators/full_doc_generator.rb

@@ -1,127 +0,0 @@
-module YARD
-  module Generators
-    class FullDocGenerator < Base
-      before_generate :is_namespace?
-      before_list :setup_options
-      before_list :generate_assets
-      before_list :generate_index
-      before_list :generate_files
-      
-      def sections_for(object) 
-        case object
-        when CodeObjects::RootObject
-          [:header, [G(RootGenerator)]]
-        when CodeObjects::ClassObject
-          [:header, [G(ClassGenerator)]]
-        when CodeObjects::ModuleObject
-          [:header, [G(ModuleGenerator)]]
-        end
-      end
-      
-      protected
-      
-      def setup_options
-        options[:readme] ||= Dir['{README,README.*}']
-        options[:files]  ||= []
-      end
-    
-      def css_file;         'style.css'             end
-      def css_custom_file;  'custom.css'            end
-      def css_syntax_file;  'syntax_highlight.css'  end
-      def js_file;          'jquery.js'             end
-      def js_app_file;      'app.js'                end
-      
-      def readme_file
-        @readme_file ||= [options[:readme]].flatten.compact.find do |readme|
-          File.exists?(readme.to_s)
-        end.to_s
-      end
-      
-      def readme_file_exists?; not readme_file.empty?; end
-      
-      def extra_files
-        [readme_file] + options[:files]
-      end
-      
-      def generate_assets
-        if format == :html && serializer
-          [css_file, css_custom_file, css_syntax_file, js_file, js_app_file].each do |filename|
-            template_file = find_template template_path(filename)
-            serializer.serialize(filename, File.read(template_file))
-          end
-        end
-        true
-      end
-      
-      def generate_index(all_objects)
-        if format == :html && serializer
-          ns = all_objects.select {|o| o.type == :module || o.type == :class }
-          all_namespaces = { 
-            :objects => ns.sort_by {|o| o.path },
-            :root => all_objects.find {|o| o.type == :root && (!o.meths.empty? || !o.constants.empty?) }
-          }
-          all_methods = { :objects => methods_to_show(all_objects) }
-          
-          serializer.serialize 'index.html', render(:index)
-          serializer.serialize 'all-files.html', render(:all_files)
-          serializer.serialize 'all-namespaces.html', render(:all_namespaces, all_namespaces)
-          serializer.serialize 'all-methods.html', render(:all_methods, all_methods)
-        end
-        true
-      end
-      
-      def generate_files
-        if format == :html && serializer 
-          extra_files.each do |file|
-            next unless File.exists?(file)
-            @contents = File.read(file)
-            file = File.basename(file)
-            serializer.serialize file + '.html', render(:file, :filename => file)
-          end
-        end
-        true
-      end
-      
-      def markup_for(filename)
-        case File.extname(filename).downcase
-        when /^\.(?:mdown|markdown|mkdn|markdn|md)$/
-          :markdown
-        when ".textile"
-          :textile
-        when /^\.html?$/
-          if format == :html
-            nil # no markup, use raw data
-          else
-            # TODO implement some html->plaintext markup
-            :rdoc
-          end
-        else
-          if @contents =~ /\A#!(\S+)\s*$/ # Shebang support
-            markup = $1
-            @contents.gsub!(/\A.+?\r?\n/, '')
-            markup.to_sym
-          else
-            :rdoc
-          end
-        end
-      end
-      
-      def methods_to_show(namespaces)
-        meths = namespaces.inject([]) do |arr, namespace|
-          next(arr) unless namespace.is_a?(CodeObjects::NamespaceObject)
-          more_meths = namespace.meths(:included => false, :inherited => false)
-          more_meths = more_meths.select {|object| object.is_explicit? }
-          arr += more_meths
-        end
-        if options[:verifier]
-          meths.reject! do |object|
-            # FIXME we should be using call_verifier here, but visibility
-            # is checked on the generator, not the object
-            options[:verifier].call(object, object).is_a?(FalseClass)
-          end
-        end
-        meths.sort_by {|object| object.path }
-      end
-    end
-  end
-end

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

@@ -1,196 +0,0 @@
-require 'cgi'
-
-module YARD
-  module Generators::Helpers
-    module HtmlHelper
-      include MarkupHelper
-      include HtmlSyntaxHighlightHelper
-      
-      SimpleMarkupHtml = RUBY19 ? RDoc::Markup::ToHtml.new : SM::ToHtml.new
-    
-      def h(text)
-        CGI.escapeHTML(text.to_s)
-      end
-    
-      def urlencode(text)
-        CGI.escape(text.to_s)
-      end
-
-      def htmlify(text, markup = options[:markup])
-        return text unless markup
-        load_markup_provider(markup)
-
-        # TODO: other libraries might be more complex
-        case markup
-        when :markdown
-          html = markup_class(markup).new(text).to_html
-        when :textile
-          doc = markup_class(markup).new(text)
-          doc.hard_breaks = false if doc.respond_to?(:hard_breaks=)
-          html = doc.to_html
-        when :rdoc
-          html = MarkupHelper::SimpleMarkup.convert(text, SimpleMarkupHtml)
-          html = fix_dash_dash(html)
-          html = fix_typewriter(html)
-        end
-
-        html = resolve_links(html)
-        html = html.gsub(/<pre>(?:\s*<code>)?(.+?)(?:<\/code>\s*)?<\/pre>/m) do
-          str = $1
-          str = html_syntax_highlight(CGI.unescapeHTML(str)) unless options[:no_highlight]
-          %Q{<pre class="code">#{str}</pre>}
-        end
-        html
-      end
-      
-      # @todo Refactor into own SimpleMarkup subclass
-      def fix_typewriter(text)
-        text.gsub(/\+(?! )([^\+]{1,900})(?! )\+/, '<tt>\1</tt>')
-      end
-      
-      # Don't allow -- to turn into &#8212; element. The chances of this being
-      # some --option is far more likely than the typographical meaning.
-      # 
-      # @todo Refactor into own SimpleMarkup subclass
-      def fix_dash_dash(text)
-        text.gsub(/&#8212;(?=\S)/, '--')
-      end
-
-      def resolve_links(text)
-        code_tags = 0
-        text.gsub(/<(\/)?(pre|code)|(\s|>|^)\{(\S+?)(?:\s(.*?\S))?\}(?=[\W<]|.+<\/|$)/) do |str|
-          tag = $2
-          closed = $1
-          if tag
-            code_tags += (closed ? -1 : 1)
-            next str
-          end
-          next str unless code_tags == 0
-
-          sp, name = $3, $4
-          title = $5 || name
-
-          if name.include?("://")
-            sp + link_url(name, title, :target => '_parent')
-          elsif name =~ /^file:(\S+?)(?:#(\S+))?$/
-            sp + link_file($1, title == name ? $1 : title, $2)
-          else
-            obj = Registry.resolve(current_object, name, true, true)
-            if obj.is_a?(CodeObjects::Proxy)
-              match = text[/(.{0,20}\{.*?#{Regexp.quote name}.*?\}.{0,20})/, 1]
-              log.warn "In file `#{current_object.file}':#{current_object.line}: Cannot resolve link to #{obj.path} from text" + (match ? ":" : ".")
-              log.warn '...' + match.gsub(/\n/,"\n\t") + '...' if match
-            end
-          
-            "#{sp}<tt>" + linkify(obj, title) + "</tt>" 
-          end
-        end
-      end
-
-      def format_object_name_list(objects)
-        objects.sort_by {|o| o.name.to_s.downcase }.map do |o| 
-          "<span class='name'>" + linkify(o, o.name) + "</span>" 
-        end.join(", ")
-      end
-      
-      # Formats a list of types from a tag.
-      # 
-      # @param [Array<String>, FalseClass] typelist
-      #   the list of types to be formatted. 
-      # 
-      # @param [Boolean] brackets omits the surrounding 
-      #   brackets if +brackets+ is set to +false+.
-      # 
-      # @return [String] the list of types formatted
-      #   as [Type1, Type2, ...] with the types linked
-      #   to their respective descriptions.
-      # 
-      def format_types(typelist, brackets = true)
-        return unless typelist.is_a?(Array)
-        list = typelist.map do |type| 
-          "<tt>" + type.gsub(/(^|[<>])\s*([^<>#]+)\s*(?=[<>]|$)/) {|m| h($1) + linkify($2, $2) } + "</tt>"
-        end
-        list.empty? ? "" : (brackets ? "[#{list.join(", ")}]" : list.join(", "))
-      end
-      
-      def link_file(filename, title = nil, anchor = nil)
-        link_url(url_for_file(filename, anchor), title)
-      end
-    
-      def link_object(object, otitle = nil, anchor = nil, relative = true)
-        object = Registry.resolve(current_object, object, true, true) if object.is_a?(String)
-        title = h(otitle ? otitle.to_s : object.path)
-        return title unless serializer
-
-        return title if object.is_a?(CodeObjects::Proxy)
-      
-        link = url_for(object, anchor, relative)
-        link ? link_url(link, title) : title
-      end
-      
-      def link_url(url, title = nil, params = {})
-        params = SymbolHash.new(false).update(
-          :href => url,
-          :title  => title || url
-        ).update(params)
-        "<a #{tag_attrs(params)}>#{title}</a>"
-      end
-      
-      def tag_attrs(opts = {})
-        opts.map {|k,v| "#{k}=#{v.to_s.inspect}" if v }.join(" ")
-      end
-    
-      def anchor_for(object)
-        case object
-        when CodeObjects::MethodObject
-          "#{object.name}-#{object.scope}_#{object.type}"
-        when CodeObjects::Base
-          "#{object.name}-#{object.type}"
-        when CodeObjects::Proxy
-          object.path
-        else
-          object.to_s
-        end
-      end
-    
-      def url_for(object, anchor = nil, relative = true)
-        link = nil
-        return link unless serializer
-        
-        if object.is_a?(CodeObjects::Base) && !object.is_a?(CodeObjects::NamespaceObject)
-          # If the object is not a namespace object make it the anchor.
-          anchor, object = object, object.namespace
-        end
-        
-        objpath = serializer.serialized_path(object)
-        return link unless objpath
-      
-        if relative
-          fromobj = current_object
-          if current_object.is_a?(CodeObjects::Base) && 
-              !current_object.is_a?(CodeObjects::NamespaceObject)
-            fromobj = fromobj.namespace
-          end
-
-          from  = serializer.serialized_path(fromobj)
-          link  = File.relative_path(from, objpath)
-        else
-          link = objpath
-        end
-      
-        link + (anchor ? '#' + urlencode(anchor_for(anchor)) : '')
-      end
-      
-      def url_for_file(filename, anchor = nil)
-        fromobj = current_object
-        if CodeObjects::Base === fromobj && !fromobj.is_a?(CodeObjects::NamespaceObject)
-          fromobj = fromobj.namespace
-        end
-        from = serializer.serialized_path(fromobj)
-        link = File.relative_path(from, filename)
-        link + '.html' + (anchor ? '#' + urlencode(anchor) : '')
-      end
-    end
-  end
-end
-