distil 0.11.6 → 0.11.8

data/vendor/pdoc/lib/pdoc/generators/html/helpers.rb

@@ -0,0 +1,256 @@
+module PDoc
+  module Generators
+    module Html
+      module Helpers
+        module BaseHelper
+          def content_tag(tag_name, content, attributes = {})
+            "<#{tag_name}#{attributes_to_html(attributes)}>#{content}</#{tag_name}>"
+          end
+
+          def img_tag(filename, attributes = {})
+            attributes.merge! :src => "#{path_prefix}images/#{filename}"
+            tag(:img, attributes)
+          end
+
+          def tag(tag_name, attributes = {})
+            "<#{tag_name}#{attributes_to_html(attributes)} />"
+          end
+          
+          def link_to(name, path, attributes={})
+            content_tag(:a, name, attributes.merge(:href => path))
+          end
+          
+          def htmlize(markdown)
+            markdown = Website.syntax_highlighter.parse(markdown)
+            Website.markdown_parser.new(markdown).to_html
+          end
+          
+          # Gah, what an ugly hack.
+          def inline_htmlize(markdown)
+            htmlize(markdown).gsub(/^<p>/, '').gsub(/<\/p>$/, '')
+          end
+          
+          def javascript_include_tag(*names)
+            names.map do |name|
+              attributes = {
+                :src => "#{path_prefix}javascripts/#{name}.js",
+                :type => "text/javascript",
+                :charset => "utf-8"
+              }
+              content_tag(:script, "", attributes)
+            end.join("\n")
+          end
+
+          def stylesheet_link_tag(*names)
+            names.map do |name|
+              attributes = {
+                :href => "#{path_prefix}stylesheets/#{name}.css",
+                :type => "text/css",
+                :media => "screen, projection",
+                :charset => "utf-8",
+                :rel => "stylesheet"
+              }
+              tag(:link, attributes)
+            end.join("\n")
+          end
+          
+          private
+            def attributes_to_html(attributes)
+              attributes = attributes.sort { |a, b| a.to_s <=> b.to_s }
+              attributes.map do |a|
+                k, v = a
+                k ? " #{k}=\"#{v}\"" : ""
+              end.join
+            end
+        end
+        
+        module LinkHelper
+          def path_prefix
+            "../" * depth
+          end
+          
+          def path_to(obj)
+            path = path_prefix << obj.url << '/'
+            Website.pretty_urls? ? path : "#{path}index.html"
+          end
+          
+          def auto_link(obj, options = {})
+            if obj.is_a?(String)
+              original = obj
+              obj = root.find(obj)
+              return original unless obj
+            end
+            name = options.delete(:name) == :short ? obj.name : obj.full_name
+            if obj.type == 'section'
+              title = obj.full_name
+            else
+              title = "#{obj.full_name} (#{obj.type})"
+            end
+            link_to(name, path_to(obj), { :title => title }.merge(options))
+          end
+          
+          def auto_link_code(obj, options = {})
+            "<code>#{auto_link(obj, options)}</code>"
+          end
+
+          def auto_link_content(content)
+            return '' if content.nil?
+            content.gsub!(/\[\[([a-zA-Z]+)\s+section\]\]/) do |m|
+              result = auto_link(root.find($1), :name => :long)
+              result
+            end
+            content.gsub(/\[\[([a-zA-Z$\.#]+)(?:\s+([^\]]+))?\]\]/) do |m|
+              if doc_instance = root.find($1)
+                $2 ? link_to($2, path_to(doc_instance)) : auto_link_code(doc_instance, :name => :long)
+              else
+                $1
+              end
+            end
+          end
+          
+          def auto_link_types(types, options = {})
+            types = types.split(/\s+\|\s+/) if types.is_a?(String)
+            types.map do |t|
+              if match = /^\[([\w\d\$\.\(\)#]*[\w\d\$\(\)#])...\s*\]$/.match(t) # e.g.: [Element...]
+                "[#{auto_link(match[1], options)}…]"
+              else
+                auto_link(t, options)
+              end
+            end
+          end
+          
+          def dom_id(obj)
+            "#{obj.id}-#{obj.type.gsub(/\s+/, '_')}"
+          end
+        end
+        
+        module CodeHelper
+          def methodize_signature(sig)
+            sig.sub(/\.([\w\d\$]+)\((.*?)(,\s*|\))/) do
+              first_arg = $2.to_s.strip
+              prefix = first_arg[-1, 1] == '[' ? '([' : '('
+              rest = $3 == ')' ? $3 : ''
+              "##{$1}#{prefix}#{rest}"
+            end
+          end
+          
+          def methodize_full_name(obj)
+            obj.full_name.sub(/\.([^.]+)$/, '#\1')
+          end
+          
+          def method_synopsis(object)
+            result = []
+            object.signatures.each do |signature|
+              if return_value = signature.return_value
+                types = auto_link_types(return_value, :name => :long).join(' | ')
+                result << "#{signature.name} &rarr; #{types}"
+              else # Constructors
+                result << signature.name
+              end
+            end
+            result
+          end
+          
+          def breadcrumb(obj, options = {})
+            options = {:name => :short}.merge(options)
+            result = []
+            begin
+              result << auto_link(obj, options.dup)
+              obj = obj.parent
+            end until obj.is_a?(Models::Root)
+            result.reverse!
+          end
+        end
+        
+        module MenuHelper
+          NODES = [
+            :namespaces,
+            :classes,
+            :mixins,
+            :utilities
+          ]
+          LEAVES = [
+            :constants,
+            :class_methods,
+            :class_properties,
+            :instance_methods,
+            :instance_properties
+          ]
+          
+          def menu(obj)
+            if obj.parent
+              html = menu_item(obj, :name => :long)
+            
+              html << node_submenu(obj)
+            
+              if obj == doc_instance && obj.respond_to?(:constants)
+                html << leaf_submenu(obj)
+              elsif doc_instance && doc_instance.respond_to?(:parent)
+                parent = doc_instance.parent
+                html << leaf_submenu(parent) if parent == obj && obj.respond_to?(:constants)
+              end
+            
+              content_tag(:li, html)
+            else #root
+              node_submenu(obj)
+            end
+          end
+          
+          def node_submenu(obj)
+            children = []
+            options = {}
+            
+            NODES.each do |prop|
+              children.concat(obj.send(prop)) if obj.respond_to?(prop)
+            end
+            
+            list_items = children.sort.map { |item| menu(item) }
+            if obj.respond_to?(:sections)
+              obj.sections.each { |section| list_items << menu(section) }
+              options[:class] = "menu-items"
+              options[:id] = "api_menu"
+            elsif obj.type == "section"
+              options[:class] = "menu-section"
+            end
+            list_items.empty? ? '' : content_tag(:ul, list_items.join("\n"), options)
+          end
+          
+          def menu_item(obj, options = {})
+            options = options.dup
+            options[:class] = class_names_for(obj, options)
+            content_tag(:div, auto_link(obj, options), :class => 'menu-item')
+          end
+          
+          def leaf_submenu(obj)
+            items = []
+            if obj.respond_to?(:constructor) && obj.constructor
+              items << content_tag(:li, menu_item(obj.constructor, :name => :short))
+            end
+            LEAVES.each do |prop|
+              if obj.respond_to?(prop)
+                obj.send(prop).sort!.map do |item|
+                  items << content_tag(:li, menu_item(item, :name => :short))
+                end
+              end
+            end
+            content_tag(:ul, items.join("\n"))
+          end
+          
+          def class_names_for(obj, options = {})
+            classes = []
+            classes << obj.type.gsub(/\s+/, '-')
+            classes << "deprecated" if obj.deprecated?
+            if doc_instance
+              if obj == doc_instance
+                classes << "current"
+              elsif obj.ancestor_of?(doc_instance)
+                classes << "current-parent"
+              end
+            end
+            classes.join(' ')
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/generators/html/page.rb

@@ -0,0 +1,71 @@
+module PDoc
+  module Generators
+    module Html
+      class Page
+
+        include Helpers::BaseHelper
+        include Helpers::LinkHelper
+        
+        def initialize(template, layout, variables = {})
+          @template = template
+          @layout = layout
+          assign_variables(variables)
+        end
+        
+        # Renders the page as a string using the assigned layout.
+        def render
+          if @layout
+            @content_for_layout = Template.new(@template, @templates_directory).result(binding)
+            Template.new(@layout, @templates_directory).result(binding)
+          else
+            Template.new(@template, @templates_directory).result(binding)
+          end
+        end
+        
+        # Creates a new file and renders the page to it
+        # using the assigned layout.
+        def render_to_file(filename)
+          filename ||= ""
+          FileUtils.mkdir_p(File.dirname(filename))
+          File.open(filename, "w+") { |f| f << render }
+        end
+        
+        def include(path, options = {})
+          r = ''
+          options.each { |k, v| r << "#{k.to_s} = options[:#{k}];" }
+          eval(r)
+          
+          if options[:collection]
+            options[:collection].map { |object| Template.new(path, @templates_directory).result(binding) }.join("\n")
+          else
+            Template.new(path, @templates_directory).result(binding)
+          end
+        end
+        
+        private
+          def assign_variables(variables)
+            variables.each { |key, value| instance_variable_set("@#{key}", value) }
+          end
+      end
+
+      class DocPage < Page
+        include Helpers::LinkHelper, Helpers::CodeHelper, Helpers::MenuHelper
+        
+        attr_reader :doc_instance, :depth, :root
+        
+        def initialize(template, layout = "layout", variables = {})
+          if layout.is_a?(Hash)
+            variables = layout
+            layout = "layout"
+          end
+          super(template, layout, variables)
+        end
+        
+        def htmlize(markdown)
+          super(auto_link_content(markdown))
+        end
+      end
+      
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/generators/html/syntax_highlighter.rb

@@ -0,0 +1,41 @@
+module PDoc
+  module Generators
+    module Html
+      class SyntaxHighlighter
+        CODE_BLOCK_REGEXP = /(?:\n\n|\A)(?:\s{4,}lang(?:uage)?:\s*(\w+)\s*\n)?((?:\s{4}.*\n*)+)(^\s{0,3}\S|\z)?/
+        
+        attr_reader :highlighter
+        
+        def initialize(h = nil)
+          @highlighter = h.nil? ? :none : h.to_sym
+        end
+        
+        def parse(input)
+          input.gsub(CODE_BLOCK_REGEXP) do |block|
+            language, codeblock, remainder = $1, $2, $3
+            codeblock = codeblock.gsub(/^\s{4}/, '').rstrip
+            "\n\n#{highlight_block(codeblock, language)}\n#{remainder}"
+          end
+        end
+        
+        def highlight_block(code, language)
+          language = :javascript if language.nil?
+          case highlighter.to_sym
+            when :none
+              require 'cgi'
+              code = CGI.escapeHTML(code)
+              "<pre><code class=\"#{language}\">#{code}</code></pre>"
+            when :coderay
+              require 'coderay'
+              CodeRay.scan(code, language).div
+            when :pygments
+              require 'albino'
+              Albino.new(code, language).colorize
+          else
+            raise "Requested unsupported syntax highlighter: #{highlighter}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/generators/html/template.rb

@@ -0,0 +1,37 @@
+begin
+  require 'erubis'
+rescue LoadError
+end
+
+module PDoc
+  module Generators
+    module Html
+      class Template
+        def initialize(file_name = "layout.erb", templates_directory = nil)
+          @file_name = file_name
+          @templates_directory = templates_directory
+          @template = create_template(IO.read(file_path))
+        end
+        
+        def result(binding)
+          @template.result(binding)
+        end
+        
+        private
+          def file_path
+            @file_name << '.erb' unless @file_name =~ /\.erb$/
+            path = File.join(@templates_directory, @file_name.split("/"))
+            File.expand_path(path, DIR)
+          end
+          
+          def create_template(input)
+            if defined?(Erubis)
+              Erubis::Eruby.new(input)
+            else
+              ERB.new(input, nil, '%')
+            end
+          end
+      end
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/generators/html/website.rb

@@ -0,0 +1,194 @@
+module PDoc
+  module Generators
+    module Html
+      
+      unless defined? TEMPLATES_DIRECTORY
+        TEMPLATES_DIRECTORY = File.join(TEMPLATES_DIR, "html")
+      end
+      
+      class Website < AbstractGenerator
+        
+        include Helpers::BaseHelper
+        include Helpers::LinkHelper
+        
+        class << Website
+          attr_accessor :syntax_highlighter
+          attr_accessor :markdown_parser
+          def pretty_urls?
+            !!@pretty_urls
+          end
+          
+          def pretty_urls=(boolean)
+            @pretty_urls = boolean
+          end
+        end
+        attr_reader :templates_directory, :custom_assets, :index_page
+        def initialize(parser_output, options = {})
+          super
+          @templates_directory = File.expand_path(options[:templates] || TEMPLATES_DIRECTORY)
+          @index_page = options[:index_page] && File.expand_path(options[:index_page])
+          @custom_assets = @options[:assets] && File.expand_path(@options[:assets])
+          self.class.syntax_highlighter = SyntaxHighlighter.new(options[:syntax_highlighter])
+          self.class.pretty_urls = options[:pretty_urls]
+          set_markdown_parser(options[:markdown_parser])
+          load_custom_helpers
+        end
+        
+        def set_markdown_parser(parser = nil)
+          parser = :rdiscount if parser.nil?
+          case parser.to_sym
+          when :rdiscount
+            require 'rdiscount'
+            self.class.markdown_parser = RDiscount
+          when :bluecloth
+            require 'bluecloth'
+            self.class.markdown_parser = BlueCloth
+          when :maruku
+            require 'maruku'
+            self.class.markdown_parser = Maruku
+          else
+            raise "Requested unsupported Markdown parser: #{parser}."
+          end
+        end
+        
+        def load_custom_helpers
+          begin
+            require File.join(templates_directory, "helpers")
+          rescue LoadError => e
+            return nil
+          end
+          self.class.__send__(:include, Helpers::BaseHelper)
+          Page.__send__(:include, Helpers::BaseHelper)
+          Helpers.constants.map(&Helpers.method(:const_get)).each(&DocPage.method(:include))
+        end
+        
+        # Generates the website to the specified directory.
+        def render(output)
+          @depth = 0
+          path = File.expand_path(output)
+          FileUtils.mkdir_p(path)
+          Dir.chdir(path) do
+          
+            render_index
+            copy_assets
+            copy_custom_assets
+            
+            render_children(root)
+            if root.sections?
+              root.sections.each do |section|
+                @depth = 0
+                render_template('section', { :doc_instance => section })
+              end
+            end
+
+            dest = File.join("javascripts", "pdoc", "item_index.js")
+            DocPage.new("item_index.js", false, variables).render_to_file(dest)
+          end
+        end
+        
+        def render_index
+          vars = variables.merge(:index_page_content => index_page_content, :home => true)
+          DocPage.new('index', 'layout', vars).render_to_file('index.html')
+        end
+        
+        def render_template(template, var = {})
+          @depth += 1
+          doc = var[:doc_instance]
+          dest = doc.url(File::SEPARATOR)
+          puts "        Rendering #{dest}..."
+          FileUtils.mkdir_p(dest)
+          DocPage.new(template, variables.merge(var)).render_to_file(File.join(dest, 'index.html'))
+          render_json("#{dest}.json", doc) if json_api?
+          render_children(doc)
+          @depth -= 1
+        end
+        
+        def render_json(dest, obj)
+          open(dest, 'w') { |file| file << obj.to_json }
+        end
+        
+        def render_children(obj)
+          [:namespaces, :classes, :mixins].each do |prop|
+            obj.send(prop).each(&method(:render_node)) if obj.respond_to?(prop)
+          end
+          
+          obj.utilities.each(&method(:render_leaf)) if obj.respond_to?(:utilities)
+          render_leaf(obj.constructor) if obj.respond_to?(:constructor) && obj.constructor
+          
+          [:instance_methods, :instance_properties, :class_methods, :class_properties, :constants].each do |prop|
+            obj.send(prop).each(&method(:render_leaf)) if obj.respond_to?(prop)
+          end
+        end
+        
+        # Copies the content of the assets folder to the generated website's
+        # root directory.
+        def copy_assets
+          FileUtils.cp_r(Dir.glob(File.join(templates_directory, "assets", "**")), '.')
+        end
+        
+        def copy_custom_assets
+          if custom_assets
+            FileUtils.cp_r(Dir.glob(File.join(custom_assets, "**")), ".")
+          end
+        end
+        
+        def render_leaf(object)
+          is_proto_prop = is_proto_prop?(object)
+          @depth += 1 if is_proto_prop
+          render_template('leaf', { :doc_instance => object })
+          @depth -= 1 if is_proto_prop
+        end
+        
+        def render_node(object)          
+          render_template('node', { :doc_instance => object })
+        end
+        
+        private
+          def variables
+            {
+              :root => root,
+              :depth => @depth,
+              :templates_directory => templates_directory,
+              :name => @options[:name],
+              :short_name => @options[:short_name] || @options[:name],
+              :home_url => @options[:home_url],
+              :version => @options[:version],
+              :footer => footer,
+              :index_header => index_header,
+              :header => header,
+              :timestamp => timestamp
+            }
+          end
+
+          def header
+            @header ||= @options[:header] ? htmlize(@options[:header]) : ''
+          end
+          
+          def index_header
+            @index_header ||= @options[:index_header] ? htmlize(@options[:index_header]) : ''
+          end
+          
+          def footer
+            @footer ||= @options[:footer] ? htmlize(@options[:footer]) : ''
+          end
+          
+          def timestamp
+            @timestamp ||= @options[:timestamp] == false ? nil : Time.now.utc
+          end
+          
+          def json_api?
+            !!options[:json_api]
+          end
+          
+          def is_proto_prop?(object)
+            object.is_a?(Models::InstanceMethod) ||
+              object.is_a?(Models::InstanceProperty)
+          end
+          
+          def index_page_content
+            @index_page ? htmlize(File.read(@index_page)) : nil
+          end
+      end
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/generators/html.rb

@@ -0,0 +1,8 @@
+HTML_DIR = File.expand_path(File.join(File.dirname(__FILE__), "html"))
+
+require File.join(HTML_DIR, "helpers")
+require File.join(HTML_DIR, "template")
+require File.join(HTML_DIR, "page")
+require File.join(HTML_DIR, "website")
+require File.join(HTML_DIR, "syntax_highlighter")
+

data/vendor/pdoc/lib/pdoc/generators/json.rb

@@ -0,0 +1,15 @@
+require 'json'
+module PDoc
+  module Generators
+    class JSON < AbstractGenerator
+      def render(output)
+        open(output, "w+") do |file|
+          json = root.registry.map do |k, obj|
+            "#{k.inspect}: #{obj.to_json}"
+          end.join(",\n  ")
+          file << "{\n  #{json}\n}"
+        end
+      end
+    end
+  end
+end