jsduck 4.10.4 → 5.0.0.beta01

data/lib/jsduck/return_values.rb

@@ -1,72 +0,0 @@
-module JsDuck
-
-  # Auto-detector return values and @chainable tags.
-  #
-  # Adds @chainable tag when doc-comment contains @return {OwnerClass}
-  # this.  Also the other way around: when @chainable found, adds
-  # appropriate @return.
-  class ReturnValues
-    # Only this static method of this class should be called.
-    def self.auto_detect(relations)
-      ReturnValues.new(relations).process_all!
-    end
-
-    def initialize(relations)
-      @relations = relations
-      @cls = nil
-    end
-
-    def process_all!
-      @relations.each do |cls|
-        @cls = cls
-        cls.find_members(:tagname => :method, :local => true, :static => false).each do |m|
-          process(m)
-        end
-      end
-    end
-
-    private
-
-    def process(m)
-      if constructor?(m)
-        add_return_new(m)
-      elsif chainable?(m)
-        add_return_this(m)
-      elsif returns_this?(m)
-        add_chainable(m)
-      end
-    end
-
-    def constructor?(m)
-      m[:name] == "constructor"
-    end
-
-    def chainable?(m)
-      m[:meta][:chainable]
-    end
-
-    def returns_this?(m)
-      m[:return] && m[:return][:type] == @cls[:name] && m[:return][:doc] =~ /\Athis\b/
-    end
-
-    def add_chainable(m)
-      m[:meta][:chainable] = true
-    end
-
-    def add_return_this(m)
-      if m[:return][:type] == "undefined" && m[:return][:doc] == ""
-        m[:return] = {:type => @cls[:name], :doc => "this"}
-      end
-    end
-
-    def add_return_new(m)
-      if m[:return][:type] == "undefined" || m[:return][:type] == "Object"
-        # Create a whole new :return hash.
-        # If we were to just change the :type field it would modify
-        # the type of all the inherited constructor docs.
-        m[:return] = {:type => @cls[:name], :doc => m[:return][:doc]}
-      end
-    end
-  end
-
-end

data/lib/jsduck/serializer.rb

@@ -1,262 +0,0 @@
-module JsDuck
-
-  # Transforms Esprima AST into string
-  class Serializer
-
-    # Turns AST node into string
-    def to_s(ast)
-      case ast["type"]
-      when "Program"
-        ast["body"].map {|s| to_s(s) }.join
-
-      # Statements
-
-      when "BlockStatement"
-        "{" + ast["body"].map {|s| to_s(s) }.join + "}"
-
-      when "BreakStatement"
-        "break" + (ast["label"] ? " " + to_s(ast["label"]) : "") + ";"
-
-      when "ContinueStatement"
-        "continue" + (ast["label"] ? " " + to_s(ast["label"]) : "") + ";"
-
-      when "DoWhileStatement"
-        "do " + to_s(ast["body"]) + " while (" + to_s(ast["test"]) + ");"
-
-      when "DebuggerStatement"
-        "debugger;"
-
-      when "EmptyStatement"
-        ";"
-
-      when "ExpressionStatement"
-        to_s(ast["expression"]) + ";"
-
-      when "ForStatement"
-        init = ast["init"] ? to_s(ast["init"]).sub(/;\Z/, "") : ""
-        test = ast["test"] ? to_s(ast["test"]) : ""
-        update = ast["update"] ? to_s(ast["update"]) : ""
-        "for (" + init + "; " + test + "; " + update + ") " + to_s(ast["body"])
-
-      when "ForInStatement"
-        left = to_s(ast["left"]).sub(/;\Z/, "")
-        right = to_s(ast["right"])
-        "for (" + left + " in " + right + ") " + to_s(ast["body"])
-
-      when "IfStatement"
-        alternate = ast["alternate"] ? " else " + to_s(ast["alternate"]) : ""
-        "if (" + to_s(ast["test"]) + ") " + to_s(ast["consequent"]) + alternate
-
-      when "LabeledStatement"
-        to_s(ast["label"]) + ": " + to_s(ast["body"])
-
-      when "ReturnStatement"
-        arg = ast["argument"] ? to_s(ast["argument"]) : ""
-        "return " + arg + ";"
-
-      when "SwitchStatement"
-        "switch (" + to_s(ast["discriminant"]) + ") {" + ast["cases"].map {|c| to_s(c) }.join + "}"
-
-      when "SwitchCase"
-        test = ast["test"] ? "case " + to_s(ast["test"]) : "default"
-        test + ": " + ast["consequent"].map {|c| to_s(c) }.join
-
-      when "ThrowStatement"
-        "throw " + to_s(ast["argument"]) + ";"
-
-      when "TryStatement"
-        handlers = ast["handlers"].map {|h| to_s(h) }.join
-        finalizer = ast["finalizer"] ? " finally " + to_s(ast["finalizer"]) : ""
-        "try " + to_s(ast["block"]) + handlers + finalizer
-
-      when "CatchClause"
-        param = ast["param"] ? to_s(ast["param"]) : ""
-        " catch (" + param + ") " + to_s(ast["body"])
-
-      when "WhileStatement"
-        "while (" + to_s(ast["test"]) + ") " + to_s(ast["body"])
-
-      when "WithStatement"
-        "with (" + to_s(ast["object"]) + ") " + to_s(ast["body"])
-
-
-      # Declarations
-
-      when "FunctionDeclaration"
-        function(ast)
-
-      when "VariableDeclaration"
-        ast["kind"] + " " + list(ast["declarations"]) + ";"
-
-      when "VariableDeclarator"
-        if ast["init"]
-          to_s(ast["id"]) + " = " + to_s(ast["init"])
-        else
-          to_s(ast["id"])
-        end
-
-      # Expressions
-
-      when "AssignmentExpression"
-        parens(ast, ast["left"]) + " " + ast["operator"] + " " + to_s(ast["right"])
-
-      when "ArrayExpression"
-        "[" + list(ast["elements"]) + "]"
-
-      when "BinaryExpression"
-        binary(ast)
-
-      when "CallExpression"
-        call(ast)
-
-      when "ConditionalExpression"
-        parens(ast, ast["test"]) + " ? " + to_s(ast["consequent"]) + " : " + to_s(ast["alternate"])
-
-      when "FunctionExpression"
-        function(ast)
-
-      when "LogicalExpression"
-        binary(ast)
-
-      when "MemberExpression"
-        if ast["computed"]
-          parens(ast, ast["object"]) + "[" + to_s(ast["property"]) + "]"
-        else
-          parens(ast, ast["object"]) + "." + to_s(ast["property"])
-        end
-
-      when "NewExpression"
-        "new " + call(ast)
-
-      when "ObjectExpression"
-        "{" + list(ast["properties"]) + "}"
-
-      when "Property"
-        to_s(ast["key"]) + ": " + to_s(ast["value"])
-
-      when "SequenceExpression"
-        list(ast["expressions"])
-
-      when "ThisExpression"
-        "this"
-
-      when "UnaryExpression"
-        ast["operator"] + parens(ast, ast["argument"])
-
-      when "UpdateExpression"
-        if ast["prefix"]
-          ast["operator"] + parens(ast, ast["argument"])
-        else
-          parens(ast, ast["argument"]) + ast["operator"]
-        end
-
-      # Basics
-
-      when "Identifier"
-        ast["name"]
-
-      when "Literal"
-        ast["raw"]
-
-      else
-        throw "Unknown node type: "+ast["type"]
-      end
-    end
-
-    private
-
-    # serializes function declaration or expression
-    def function(ast)
-      params = list(ast["params"])
-      id = ast["id"] ? to_s(ast["id"]) : ""
-      "function " + id + "(" + params + ") " + to_s(ast["body"])
-    end
-
-    # serializes list of comma-separated items
-    def list(array)
-      array.map {|x| to_s(x) }.join(", ")
-    end
-
-    # serializes call- and new-expression
-    def call(ast)
-      parens(ast, ast["callee"]) + "(" + list(ast["arguments"]) + ")"
-    end
-
-    # Handles both binary- and logical-expression
-    def binary(ast)
-      parens(ast, ast["left"]) + " " + ast["operator"] + " " + parens(ast, ast["right"])
-    end
-
-    # serializes child node and wraps it inside parenthesis if the
-    # precedence rules compared to parent node would require so.
-    def parens(parent, child)
-      if precedence(parent) >= precedence(child)
-        to_s(child)
-      else
-        "(" + to_s(child) + ")"
-      end
-    end
-
-    # Returns the precedence of operator represented by given AST node
-    def precedence(ast)
-      p = PRECEDENCE[ast["type"]]
-      if p.is_a? Fixnum
-        p
-      elsif p.is_a? Hash
-        p[ast["operator"]]
-      else
-        0
-      end
-    end
-
-    # Precedence rules of JavaScript operators.
-    #
-    # Taken from: https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
-    #
-    PRECEDENCE = {
-      "SequenceExpression" => 17,
-      "AssignmentExpression" => 16,
-      "ConditionalExpression" => 15,
-      "LogicalExpression" => {
-        "||" => 14,
-        "&&" => 13,
-      },
-      "BinaryExpression" => {
-        "|" => 12,
-        "^" => 11,
-        "&" => 10,
-
-        "==" => 9,
-        "!=" => 9,
-        "===" => 9,
-        "!==" => 9,
-
-        "<" => 8,
-        "<=" => 8,
-        ">" => 8,
-        ">=" => 8,
-        "in" => 8,
-        "instanceof" => 8,
-
-        "<<" => 7,
-        ">>" => 7,
-        ">>>" => 7,
-
-        "+" => 6,
-        "-" => 6,
-
-        "*" => 5,
-        "/" => 5,
-        "%" => 5,
-      },
-      "UnaryExpression" => 4,
-      "UpdateExpression" => 3,
-      "CallExpression" => 2,
-      "MemberExpression" => 1,
-      "NewExpression" => 1,
-    }
-
-  end
-
-end
-

data/lib/jsduck/shortener.rb

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'jsduck/util/html'
-require 'jsduck/util/singleton'
-
-module JsDuck
-
-  # Little helper for shortening text
-  class Shortener
-    include Util::Singleton
-
-    # Maximum length for text that doesn't get shortened.
-    # The accessor is used for testing purposes only.
-    attr_accessor :max_length
-
-    def initialize
-      @max_length = 120
-    end
-
-    # Shortens text
-    #
-    # 116 chars is also where ext-doc makes its cut, but unlike
-    # ext-doc we only make the cut when there's more than 120 chars.
-    #
-    # This way we don't get stupid expansions like:
-    #
-    #   Blah blah blah some text...
-    #
-    # expanding to:
-    #
-    #   Blah blah blah some text.
-    #
-    def shorten(input)
-      sent = first_sentence(Util::HTML.strip_tags(input).strip)
-      # Use u-modifier to correctly count multi-byte characters
-      chars = sent.scan(/./mu)
-      if chars.length > @max_length
-        chars[0..(@max_length-4)].join + "..."
-      else
-        sent + " ..."
-      end
-    end
-
-    # Returns the first sentence inside a string.
-    def first_sentence(str)
-      str.sub(/\A(.+?(\.|。))\s.*\Z/mu, "\\1")
-    end
-
-    # Returns true when input should get shortened.
-    def too_long?(input)
-      stripped = Util::HTML.strip_tags(input).strip
-      # for sentence v/s full - compare byte length
-      # for full v/s max - compare char length
-      first_sentence(stripped).length < stripped.length || stripped.scan(/./mu).length > @max_length
-    end
-
-  end
-
-end

data/lib/jsduck/signature_renderer.rb

@@ -1,91 +0,0 @@
-require 'jsduck/meta_tag_renderer'
-
-module JsDuck
-
-  # Performs the rendering of member signatures.
-  class SignatureRenderer
-    # Initializes the renderer for rendering members of the given
-    # class.
-    def initialize(cls)
-      @cls = cls
-    end
-
-    # Renders signature of the given member.
-    def render(member)
-      # Keep the code simpler by not passing around the member hash
-      @m = member
-
-      return [
-        render_new,
-        render_link,
-        render_type,
-        render_meta,
-      ]
-    end
-
-    private
-
-    def render_new
-      constructor? ? "<strong class='new-keyword'>new</strong>" : ""
-    end
-
-    def render_link
-      "<a href='#{render_url}' class='name #{render_expandable}'>#{render_name}</a>"
-    end
-
-    def render_url
-      "#!/api/#{@m[:owner]}-#{@m[:id]}"
-    end
-
-    def render_expandable
-      @m[:shortDoc] ? "expandable" : "not-expandable"
-    end
-
-    def render_name
-      constructor? ? @cls[:name] : @m[:name]
-    end
-
-    def constructor?
-      @m[:tagname] == :method && @m[:name] == "constructor"
-    end
-
-    def render_type
-      if like_property?
-        render_property_type
-      else
-        render_params + render_return
-      end
-    end
-
-    def like_property?
-      @m[:tagname] == :cfg || @m[:tagname] == :property || @m[:tagname] == :css_var
-    end
-
-    def render_property_type
-      "<span> : #{@m[:html_type]}</span>"
-    end
-
-    def render_params
-      ps = @m[:params].map {|p| render_single_param(p) }.join(", ")
-      "( <span class='pre'>#{ps}</span> )"
-    end
-
-    def render_single_param(param)
-      param[:optional] ? "["+param[:name]+"]" : param[:name]
-    end
-
-    def render_return
-      method_with_return? ? (" : " + @m[:return][:html_type]) : ""
-    end
-
-    def method_with_return?
-      @m[:tagname] == :method && @m[:return][:type] != "undefined"
-    end
-
-    def render_meta
-      MetaTagRenderer.render_signature(@m)
-    end
-
-  end
-
-end