distil 0.11.6 → 0.11.8

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

@@ -0,0 +1,47 @@
+$:.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/parser/argument_description_nodes.rb

@@ -0,0 +1,21 @@
+module ArgumentDescription
+  class ArgumentDescription < Treetop::Runtime::SyntaxNode
+    def name
+      first.argument_name.name.text_value
+    end
+    
+    def types
+      if first.arg_types.empty?
+        []
+      else
+        args = first.arg_types.elements.last
+        [args.argument_type.text_value].concat(args.more.elements.map{ |e| e.argument_type.text_value })
+      end
+    end
+    
+    def description
+      more_lines = more.elements.map{ |l| l.to_s.strip }.reject { |l| l.empty? }
+      [first.description.text_value.strip].concat(more_lines).join(" ")
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/parser/basic_nodes.rb

@@ -0,0 +1,31 @@
+module Basic
+  class BlankLine < Treetop::Runtime::SyntaxNode
+    def to_s
+      ""
+    end
+  end
+
+  class TextLine < Treetop::Runtime::SyntaxNode
+    def to_s
+      text.text_value
+    end
+  end
+
+  class Line < Treetop::Runtime::SyntaxNode
+  end
+
+  class CommentStart < Treetop::Runtime::SyntaxNode
+  end
+
+  class CommentEnd < Treetop::Runtime::SyntaxNode
+  end
+
+  class LineBreak < Treetop::Runtime::SyntaxNode
+  end
+
+  class Char < Treetop::Runtime::SyntaxNode
+  end
+
+  class Space < Treetop::Runtime::SyntaxNode
+  end
+end

data/vendor/pdoc/lib/pdoc/parser/description_nodes.rb

@@ -0,0 +1,42 @@
+module Description
+  class Text < Treetop::Runtime::SyntaxNode
+    include Enumerable
+    def each
+      elements.map { |e| e.to_s }.each { |tag| yield tag }
+    end
+    
+    def join(sep = "\n")
+      outdent.join(sep).strip
+    end
+    
+    def to_s
+      join
+    end
+    
+    def excerpt
+      
+    end
+    
+    def inspect
+      text = truncate(15).gsub(/\n/, " ").strip.inspect
+      "#<#{self.class} #{text}>"
+    end
+    
+    def truncate(num = 30)
+      to_s.length < num ? to_s : to_s.slice(0..num) << "..."
+    end
+    
+    def outdent
+      range = tab_length..-1
+      map { |l| l.slice(range) }
+    end
+    
+    private
+      def tab_length
+        reject { |l| l =~ /^\s*$/ }.map do |line|
+          line = line.slice(/^\s*/)
+          line ? line.length : 0
+        end.min || 0
+      end
+  end
+end

data/vendor/pdoc/lib/pdoc/parser/documentation_nodes.rb

@@ -0,0 +1,483 @@
+module Documentation
+  class Doc < Treetop::Runtime::SyntaxNode
+    include Enumerable
+    
+    def tags
+      @tags ||= elements.first.elements.map { |e| e.elements.last }
+    end
+
+    def each
+      tags.each { |tag| yield tag }
+    end
+    
+    # find_by_name allows you to search through all the documented instances based on the 
+    # instances Base#full_name.
+    # For example:
+    #
+    #     PDoc::Parser.new("prototype.js").parse.root.find_by_name("Element#update")
+    #
+    # Return an instance of InstanceMethod corresponding to "Element#update".
+    def find_by_name(name)
+      find { |e| e.full_name == name }
+    end
+    
+    def inspect
+      to_a.inspect
+    end
+    
+    # Returns the total number of documented instances
+    def size
+      to_a.length
+    end
+    
+    def name
+      "Home"
+    end
+    
+    def serialize(serializer)
+      each { |obj| obj.serialize(serializer) }
+    end
+  end
+  
+  module Memoized
+    def method_added(method_name)
+      if instance_method(method_name).arity.zero?
+        avoid_infinite_method_added_loop do
+          memoize(method_name)
+        end
+      end
+    end
+    
+    def memoize(method_name)
+      sanitized_name = method_name.to_s
+      sanitized_name = sanitized_name.sub(/!$/, '_bang')
+      sanitized_name = sanitized_name.sub(/\?$/, '_question_mark')
+      complete_name = "#{sanitized_name}_#{object_id.abs}"
+      
+      class_eval(<<-EVAL, __FILE__, __LINE__)
+        alias compute_#{complete_name} #{method_name}    # alias compute_section_12235760 section
+                                                         # 
+        def #{method_name}                               # def section
+          unless defined?(@#{complete_name})             #   unless defined?(@section_12235760)
+            @#{complete_name} = compute_#{complete_name} #     @section_12235760 = compute_section_12235760
+          end                                            #   end
+          @#{complete_name}                              #   @section_12235760
+        end                                              # end
+      EVAL
+    end
+    
+    def avoid_infinite_method_added_loop
+      unless @memoizing
+        @memoizing = true
+        yield
+        @memoizing = false
+      end
+    end
+  end
+  
+  class Base < Treetop::Runtime::SyntaxNode
+    extend Memoized
+    
+    # Returns an instance of Doc (the root of the tree outputed by the PDoc::Parser).
+    def root
+      parent.parent.parent
+    end
+    
+    # True if the instance was tagged as deprecated.
+    def deprecated?
+      tags.include?("deprecated")
+    end
+    
+    # If instance is tagged as an alias, alias_of returns the corresponding object.
+    # It will return nil otherwise.
+    def alias_of
+      tag = tags.find { |tag| tag.name == "alias of" }
+      tag.value if tag
+    end
+    
+    def related_to
+      tag = tags.find { |tag| tag.name == "related to" }
+      tag.value if tag
+    end
+    
+    # Returns an instance of Tags::Tags.
+    def tags
+      start.elements.last.empty? ? [] : start.elements.last
+    end
+    
+    # Returns the instance's class name.
+    def klass_name
+      ebnf.klass_name
+    end
+    
+    # Returns the instance's name. For example:
+    #     root.find_by_name("Element#update").name
+    #     # -> "update"
+    def name
+      ebnf.name
+    end
+    
+    # Returns the instance's full_name. For example:
+    #     root.find_by_name("Element#update").full_name
+    #     # -> "Element#update"
+    def full_name
+      ebnf.full_name
+    end
+    
+    # Returns the instance's namespace_string. Note that event if the instance is an method or property,
+    # the klass_name is not included in that string. So for example:
+    #
+    #     root.find_by_name("Ajax.Request#request").namespace_string
+    #     # -> "Ajax"
+    def namespace_string
+      ebnf.namespace
+    end
+    
+    # Returns the Klass instance if object is a class, nil otherwise.
+    def klass
+      nil
+    end
+    
+    # Returns the instance's closests namespace or nil when instance or instance's
+    # Klass is a global.
+    def namespace
+      @namespace ||= namespace_string.empty? ? nil : root.find_by_name(namespace_string)
+    end
+    
+    # If instance is a global, returns its Section. Else its Namespace.
+    def doc_parent
+      namespace ? namespace : section
+    end
+    
+    def ebnf_expressions
+      ebnf.elements.map { |e| e.elements.last }
+    end
+    
+    def description
+      text.to_s
+    end
+    
+    def signature
+      ebnf.text_value.strip
+    end
+    
+    def inspect
+      "#<#{self.class} #{full_name}>"
+    end
+    
+    def src_code_line
+      input.line_of(interval.last) - 1
+    end
+    
+    def parent_id
+      namespace_string.empty? ? section_name : namespace_string
+    end
+    
+    def section_name
+      if tags.include?('section')
+        value = tags.find { |tag| tag.name == 'section' }.value
+        "#{value} section"
+      end
+    end
+    
+    def to_yaml
+      str = "id: #{full_name.inspect}"
+      str << "\nparent_id: #{parent_id.inspect}" if parent_id
+      str << "\ntype: #{type}"
+      str << "\nsuperclass_id: #{superclass.inspect}" if respond_to?(:superclass) && superclass
+      str << "\nincluded: #{mixins.inspect}" if respond_to?(:mixins) && !mixins.empty?
+      str << "\nline_number: #{src_code_line}"
+      str << "\ndeprecated: true" if deprecated?
+      str << "\nalias_of: #{alias_of.inspect}" if respond_to?(:alias_of) && alias_of
+      str << "\nrelated_to: #{related_to.inspect}" if respond_to?(:related_to) && related_to
+      str << "\ndescription: |\n#{indent(description)}\n"
+    end
+    
+    def serialize(serializer)
+      serializer << to_yaml
+    end
+    
+    private
+    def indent(str, prefix = '  ')
+      str.split($/).map { |line| "#{prefix}#{line}" } * $/
+    end
+  end
+  
+  class Section < Base
+    # Returns section's name
+    def name
+      section.name
+    end
+
+    # Returns section's full_name
+    def full_name
+      "#{section.name} section"
+    end
+
+    # Returns section's title
+    def title
+      section.title
+    end
+
+    # Returns section's description
+    def description
+      section.description
+    end
+
+    # Returns section's text
+    def text
+      section.text
+    end
+    
+    # Returns nil.
+    def klass_name
+      nil
+    end
+    
+    # Returns false.
+    def global?
+      false
+    end
+    
+    # Returns nil.
+    def namespace
+      nil
+    end
+    
+    # Returns an empty string.
+    def namespace_string
+      ""
+    end
+    
+    # Returns nil.
+    def section
+      nil
+    end
+    
+    # Returns nil.
+    def doc_parent
+      nil
+    end
+    
+    # Returns "section".
+    def type
+      "section"
+    end
+  end
+  
+  class Method < Base
+    def klass
+      namespace
+    end
+    
+    def klass_name
+      ebnf_expressions.first.klass_name
+    end
+
+    def full_name
+      ebnf_expressions.first.full_name
+    end
+
+    def name
+      ebnf_expressions.first.name
+    end
+
+    def methodized?
+      ebnf_expressions.first.methodized?
+    end
+    
+    def namespace_string
+      ebnf_expressions.first.namespace
+    end
+    
+    def arguments
+      args = argument_descriptions.elements
+      args ? args.first.elements :  []
+    end
+    
+    def signature
+      ebnf_expressions.first.signature
+    end
+
+    def returns
+      ebnf_expressions.first.returns
+    end
+    
+    def fires
+      events.empty? ? [] : events.to_a
+    end
+    
+    def signatures
+      ebnf_expressions
+    end
+    
+    def serialize(serializer)
+      str = to_yaml
+      str << "\nmethodized: true" if respond_to?(:methodized?) && methodized?
+      
+      serialize_signatures(str)
+      
+      serialize_arguments(str) unless arguments.empty?
+      
+      serializer << str
+    end
+    
+    def serialize_signatures(str)
+      str << "\nsignatures:"
+      ebnf_expressions.each do |ebnf|
+        str << "\n -"
+        str << "\n  signature: #{ebnf.signature.inspect}"
+        str << "\n  return_value: #{ebnf.returns.inspect}" if ebnf.returns
+      end
+    end
+    
+    def serialize_arguments(str)
+      str << "\narguments:"
+      arguments.each do |arg|
+        str << "\n -"
+        str << "\n  name: #{arg.name}"
+        str << "\n  types: [#{arg.types.join(', ')}]" unless arg.types.empty?
+        str << "\n  description: >"
+        str << "\n    #{arg.description}\n"
+      end
+    end
+  end
+  
+  class Property < Base
+    def klass
+      namespace
+    end
+    
+    def signature
+      ebnf.signature
+    end
+    
+    def returns
+      ebnf.returns
+    end
+    
+    def serialize(serializer)
+      str = to_yaml
+      
+      str << "\nsignatures:"
+      str << "\n -"
+      str << "\n  signature: #{signature.inspect}"
+      str << "\n  return_value: #{returns.inspect}"
+
+      serializer << str
+    end
+  end
+  
+  class KlassMethod < Method
+    def klass
+      namespace.is_a?(Klass) ? namespace : nil
+    end
+    
+    def klass_name
+      klass ? klass.name : nil
+    end
+    
+    def type
+      "class method"
+    end
+  end
+  
+  class Utility < Method
+    def type
+      "utility"
+    end
+  end
+  
+  class InstanceMethod < Method
+    def type
+      "instance method"
+    end
+  end
+  
+  class Constructor < Method
+    def namespace_string
+      ebnf_expressions.first.namespace
+    end
+    
+    def type
+      "constructor"
+    end
+  end
+  
+  class KlassProperty < Property
+    def type
+      "class property"
+    end
+  end
+  
+  class InstanceProperty < Property
+    def type
+      "instance property"
+    end
+  end
+  
+  class Constant < Base
+    def klass
+      namespace.is_a?(Klass) ? namespace : nil
+    end
+    
+    def klass_name
+      klass ? klass.name : nil
+    end
+    
+    def returns
+      ebnf.returns
+    end
+    
+    def signature
+      ebnf.signature
+    end
+    
+    def type
+      "constant"
+    end
+  end
+  
+  class Namespace < Base
+    def mixins
+      ebnf.mixins.map { |m| m.full_name }
+    end
+    
+    def mixin?
+      false
+    end
+    
+    def klass?
+      false
+    end
+    
+    def type
+      "namespace"
+    end
+  end
+  
+  class Klass < Namespace
+    def klass?
+      true
+    end
+    
+    def superclass
+      sc = ebnf.superklass
+      sc.text_value if sc
+    end
+    
+    def type
+      "class"
+    end
+  end
+  
+  class Mixin < Namespace
+    def mixin?
+      true
+    end
+    
+    def type
+      "mixin"
+    end
+  end
+end

data/vendor/pdoc/lib/pdoc/parser/ebnf_arguments_nodes.rb

@@ -0,0 +1,58 @@
+module EbnfArguments
+  class Argument < Treetop::Runtime::SyntaxNode
+    def name
+      text_value.strip
+    end
+    
+    def optional?
+      false
+    end
+    
+    def default_value
+      nil
+    end
+    
+    def flatten_nested_args
+      [self]
+    end
+  end
+
+  class OptionalArgument < Treetop::Runtime::SyntaxNode
+    def name
+      required_argument.name
+    end
+    
+    def optional?
+      true
+    end
+    
+    def default_value
+      unless default.empty?
+        value = default.value.text_value.strip
+        value.empty? ? nil : value
+      end
+    end
+    
+    def flatten_nested_args
+      arguments = [self]
+      unless nested.empty?
+        nested.elements.each do |optional|
+          arguments.concat(optional.flatten_nested_args)
+        end
+      end
+      arguments
+    end
+  end
+  
+  class Arguments < Treetop::Runtime::SyntaxNode
+    def to_a
+      first_argument.flatten_nested_args + rest_arguments_flattened
+    end
+    
+    def rest_arguments_flattened
+      rest.elements.inject([]) do |args, e|
+        args.concat(e.argument.flatten_nested_args)
+      end
+    end
+  end
+end