distil 0.14.4 → 0.14.5.a

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

@@ -1,194 +0,0 @@
-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/json.rb

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

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

@@ -1,105 +0,0 @@
-module PDoc
-  module Generators
-    class Pythonesque < AbstractGenerator
-      def render(output)
-        open(output, "w+") do |file|
-          file << render_to_str
-        end
-      end
-      
-      def render_to_str
-        selected_objects.map do |k, obj|
-          js_name = to_js_name(obj)
-          desc = Description.new(obj).to_escaped_str
-          " #{js_name}.__doc__ = '#{desc}';"
-        end.join("\n")
-      end
-      
-      def to_js_name(obj)
-        if obj.is_a?(Models::InstanceMethod)
-          obj.full_name.sub('#', '.prototype.')
-        else
-          obj.full_name
-        end
-      end
-      
-      def selected_objects
-        root.registry.select do |k, v|
-          (v.is_a?(Models::InstanceMethod) ||
-          v.is_a?(Models::ClassMethod) ||
-          v.is_a?(Models::Mixin) ||
-          v.is_a?(Models::Class) ||
-          v.is_a?(Models::Namespace) ||
-          v.is_a?(Models::Utility)) && !v.alias?
-        end
-      end
-      
-      class Description
-        JS_ESCAPE_MAP = {
-          '\\'    => '\\\\',
-          '</'    => '<\/',
-          "\r\n"  => '\n',
-          "\n"    => '\n',
-          "\r"    => '\n',
-          '"'     => '\\"',
-          "'"     => "\\'"
-        }
-        
-        attr_reader :obj
-        def initialize(obj)
-          @obj = obj
-        end
-        
-        def to_str
-          return "#{obj.full_name} has been deprecated." if obj.deprecated?
-          results = []
-          results << sig
-          results << args if obj.respond_to?(:arguments) && obj.arguments?
-          results << desc
-          results << aliases if obj.aliases?
-          if obj.respond_to?(:constructor) && obj.constructor
-            results << "\nWhen called as a constructor:\n"
-            results << Description.new(obj.constructor).to_str
-          end
-          results.join("\n")
-        end
-        
-        def to_escaped_str
-          escape(to_str)
-        end
-        
-        private
-          def escape(str)
-            str.gsub(/(\\|<\/|\r\n|[\n\r"'])/) {
-              JS_ESCAPE_MAP[$1]
-            }
-          end
-        
-          def sig
-            if obj.signatures?
-              obj.signatures.map do |s|
-                s.return_value ? "#{s.name} -> #{s.return_value}" : s.name
-              end.join("\n")
-            else
-              obj.full_name
-            end
-          end
-        
-          def aliases
-            aliases = obj.aliases.map { |a| a.full_name }.join(', ')
-            "Aliased as: #{aliases}."
-          end
-        
-          def args
-            obj.arguments.map do |a|
-               "  - #{a.name} (#{a.types.join(' | ')}): #{a.description.chomp}"
-            end.join("\n")
-          end
-        
-          def desc
-            obj.short_description ? obj.short_description : ''
-          end
-      end
-    end
-  end
-end

data/vendor/pdoc/lib/pdoc/models.rb

@@ -1,47 +0,0 @@
-$:.unshift(File.dirname(__FILE__), 'models')
-
-require 'models/base'
-require 'models/entity'
-require 'models/container'
-require 'models/callable'
-require 'models/section'
-require 'models/root'
-require 'models/argument'
-require 'models/class'
-require 'models/class_method'
-require 'models/class_property'
-require 'models/constant'
-require 'models/constructor'
-require 'models/instance_method'
-require 'models/instance_property'
-require 'models/mixin'
-require 'models/namespace'
-require 'models/signature'
-require 'models/utility'
-
-module PDoc
-  module Models
-    class << Models
-      attr_accessor :src_code_href
-      attr_accessor :doc_href
-    end
-    
-    class Base
-      @@subclasses_by_type = {
-        'section' => Section,
-        'argument' => Argument,
-        'class' => Class,
-        'class method' => ClassMethod,
-        'class property' => ClassProperty,
-        'constant' => Constant,
-        'constructor' => Constructor,
-        'instance method' => InstanceMethod,
-        'instance property' => InstanceProperty,
-        'mixin' => Mixin,
-        'namespace' => Namespace,
-        'signature' => Signature,
-        'utility' => Utility
-      }
-    end
-  end
-end

data/vendor/pdoc/lib/pdoc/models/argument.rb

@@ -1,37 +0,0 @@
-module PDoc
-  module Models
-    class Argument < Base
-      attr_reader :name
-      attr_reader :default_value
-      
-      def attach_to_parent(parent)
-        parent.arguments << self
-      end
-      
-      # returns the argument's id in the form
-      # method_id:argument_name. So, for example:
-      # document.querySelectorAll:cssSelector
-      def id
-        @id ||= "#{parent.id}:#{name}"
-      end
-      
-      def optional?
-        !!@optional
-      end
-      
-      def types
-        @types ||= []
-      end
-      
-      def to_hash
-        {
-          :name => name,
-          :description => description,
-          :default_value => default_value,
-          :optional => optional?,
-          :types => types
-        }
-      end
-    end
-  end
-end

data/vendor/pdoc/lib/pdoc/models/base.rb

@@ -1,107 +0,0 @@
-module PDoc
-  module Models
-    class Base
-      @@subclasses_by_type = {}
-      
-      def self.instantiate(attributes)
-        @@subclasses_by_type[attributes['type']].new(attributes)
-      end
-      
-      attr_accessor :parent
-      attr_reader   :description
-      attr_reader   :id
-      attr_reader   :type
-      attr_reader   :file
-      attr_reader   :line_number
-      
-      def initialize(attributes = {})
-        attributes.each { |k, v| instance_variable_set("@#{k}", v) }
-      end
-      
-      def register_on(registry)
-        registry[id] = self
-      end
-      
-      def short_description
-        @short_description ||= description.split(/\n\n/).first
-      end
-      
-      def deprecated?
-        return !!@deprecated if @deprecated
-        parent.respond_to?(:deprecated?) ? parent.deprecated? : false
-      end
-      
-      def full_name
-        @id
-      end
-      
-      def name
-        @name ||= @id.match(/[\w\d\$]+$/)[0]
-      end
-      
-      def ancestor_of?(obj)
-        while obj = obj.parent
-          return true if obj == self
-        end 
-        false
-      end
-      
-      def descendant_of?(obj)
-        obj.ancestor_of?(self)
-      end
-      
-      def doc_href
-        proc = Models.doc_href
-        @doc_href ||= proc ? proc.call(self) : nil
-      end
-      
-      def url(separator = '/')
-        result = []
-        obj = self
-        begin
-          result << obj.normalized_name
-          if obj.is_a?(Models::InstanceMethod) || obj.is_a?(Models::InstanceProperty)
-            result << 'prototype'
-          end
-          obj = obj.parent
-        end until obj.is_a?(Models::Root)
-        result.reverse.join(separator)
-      end
-      
-      def to_hash
-        {
-          :deprecated => deprecated?,
-          :id => id,
-          :type => type,
-          :description => description,
-          :short_description => short_description,
-          :parent => parent.is_a?(Models::Root) ? nil : parent.id,
-          :doc_href => doc_href
-        }
-      end
-      
-      def to_json(*args)
-        to_hash.to_json(*args)
-      end
-      
-      def normalized_name
-        @normalized_name ||= name.gsub(/(^\$+$)|(^\$+)|(\$+$)|(\$+)/) do |m|
-          dollar = Array.new(m.length, 'dollar').join('-')
-          if $1
-            dollar
-          elsif $2
-            "#{dollar}-"
-          elsif $3
-            "-#{dollar}"
-          elsif $4
-            "-#{dollar}-"
-          end
-        end
-      end
-      
-      def inspect
-        "#<#{self.class} #{id}>"
-      end
-    end
-  end
-end