Commit e5ffa377 authored by Rene Saarsoo's avatar Rene Saarsoo
Browse files

Simplified Members class. 

Completely removed the unused sorting functionality.

Removed the @root variable.  Only local variable used inside create().
Generalized the logic in add_class and moved it entirely into create().

create() now returns array.  The surrounding hash is added inside App.

Renamed expandable_desc() to short_desc() - nothing expandable in it.

Few more small variable renames.

Replaced comments with more accurate ones.
parent 4047d590

lib/jsduck/app.rb

+1 −1
Original line number Diff line number Diff line
@@ -101,7 +101,7 @@ module JsDuck 
    # in JSON form into a file.

    def write_members(filename, docs)

      members = Members.new.create(docs)

      js = "Docs.membersData = " + JSON.generate( members ) + ";"

      js = "Docs.membersData = " + JSON.generate( {:data => members} ) + ";"

      File.open(filename, 'w') {|f| f.write(js) }

    end

lib/jsduck/members.rb

+21 −57
Original line number Diff line number Diff line 


module JsDuck



  # Creator of package-tree in the format expected by the

  # documentation browser UI.

  #

  # See unit test for example output.

  #

  # Creates list of all members in all classes that is used by the

  # searching feature in UI.

  class Members

    def initialize

      @root = {

        :data => []

      }

    end



    # Given list of class documentation objects returns a

    # tree-structure that can be turned into JSON that's needed by

    # documentation browser interface.

    # Given list of class documentation objects returns an array of

    # hashes describing all the members.

    def create(docs)

      docs.each {|cls| add_class(cls) }

      #sort_tree(@root)

      @root

    end



    # Sorts all child nodes, and recursively all child packages.

    def sort_tree(node)

      node[:data].sort! {|a,b| compare(a, b) }

    end



    # Comparson method that sorts package nodes before class nodes.

    def compare(a, b)

      if a[:cls] == b[:cls]

        a[:member] <=> b[:member]

      else

        a[:cls] <=> b[:cls]

      end

    end



    # When package for the class exists, add class node to that

    # package; otherwise create the package first.

    def add_class(cls)

      cls.members(:cfg).each do |m|

        @root[:data] << member_node(m, cls)

      end

      cls.members(:property).each do |m|

        @root[:data] << member_node(m, cls)

      list = []

      docs.each do |cls|

        [:cfg, :property, :method, :event].each do |type|

          cls.members(type).each do |m|

            list << member_node(m, cls)

          end

      cls.members(:method).each do |m|

        @root[:data] << member_node(m, cls)

        end

      cls.members(:event).each do |m|

        @root[:data] << member_node(m, cls)

      end

      list

    end



    # Given full doc object for class creates class node

    def member_node(m, cls)

      #puts "DBG: #{m}"

    # Creates structure representing one member

    def member_node(member, cls)

      return {

        :cls => "#{cls.full_name}",

        :member => m[:name],

        :type => m[:tagname],

        :doc => expandable_desc(m[:doc])

        :cls => cls.full_name,

        :member => member[:name],

        :type => member[:tagname],

        :doc => short_desc(member[:doc])

      }

    end



    def expandable_desc(p_doc)

      tagless = first_sentence(strip_tags(strip_links(p_doc)))

    def short_desc(str)

      tagless = first_sentence(strip_tags(strip_links(str)))

      if tagless.length > 120

        short_doc = tagless[0..116]

        ellipsis = tagless.length > short_doc.length ? "..." : ""

        "#{short_doc}#{ellipsis}"

        tagless[0..116] + ellipsis

      else

        tagless

      end