distil 0.14.4 → 0.14.5.a

data/vendor/pdoc/lib/pdoc.rb

@@ -1,32 +0,0 @@
-DIR = File.expand_path(File.dirname(__FILE__))
-OUTPUT_DIR    = File.join(DIR, '..', 'output')
-TEMPLATES_DIR = File.join(DIR, '..', 'templates')
-VENDOR_DIR    = File.join(DIR, '..', 'vendor')
-PARSER_DIR    = File.join(DIR, 'pdoc', 'parser')
-
-[DIR, VENDOR_DIR, PARSER_DIR, OUTPUT_DIR, TEMPLATES_DIR].each do |c|
-  $:.unshift(c)
-end
-
-require 'rubygems'
-require 'erb'
-require 'fileutils'
-
-require 'pdoc/error'
-require 'pdoc/runner'
-require 'pdoc/generators'
-require 'pdoc/parser'
-require 'pdoc/models'
-require 'pdoc/treemaker'
-
-module PDoc
-  def self.run(options = {})
-    Runner.new(options.dup).run
-  end
-  
-  def self.copy_templates(template_type, destination)
-    dir = File.expand_path(destination)
-    raise "File already exists: #{destination}" if File.exist?(dir)
-    FileUtils.cp_r("#{TEMPLATES_DIR}/#{template_type}", dir)
-  end
-end

data/vendor/pdoc/lib/pdoc/error.rb

@@ -1,4 +0,0 @@
-module PDoc
-  class PDocError < StandardError
-  end
-end

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

@@ -1,6 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'generators', 'abstract_generator'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'generators', 'html'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'generators', 'pythonesque'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'generators', 'json'))
-
-

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

@@ -1,16 +0,0 @@
-module PDoc
-  module Generators
-    class AbstractGenerator
-      attr_reader :options, :root
-      def initialize(root, options = {})
-        @root = root
-        @options = options
-      end
-      
-      # Creates a new directory with read, write and execute permission.
-      def mkdir(name)
-        Dir.mkdir(name, 0755)
-      end
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-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/html/helpers.rb

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

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

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

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