ruby-vpi 19.0.0 → 20.0.0

data/doc/lib/doc_proxy.rb

@@ -1,562 +0,0 @@
-#--
-# Copyright 2006 Suraj N. Kurapati
-# See the file named LICENSE for details.
-
-$: << File.basename(__FILE__)
-require 'erb_proxy'
-require 'doc_format'
-
-require 'digest/md5'
-require 'ostruct'
-require 'pp'
-
-class String
-  def digest
-    Digest::MD5.hexdigest self
-  end
-end
-
-# Processes ERB templates to produce documentation.
-# Templates may contain "<xref...>" tags where the ...
-# represents the target anchor of the cross-reference.
-class DocProxy < ErbProxy
-  Box = Struct.new(:type, :anchor, :index, :title, :id)
-  BibItem = Struct.new(:anchor, :name)
-  FootNote = Struct.new(:anchor, :name)
-
-  GROUP2TYPES = {
-    :admonition => [:tip, :note, :important, :caution, :warning],
-
-    # see http://www.sagehill.net/docbookxsl/FormalTitles.html
-    :formal => [:figure, :table, :example, :equation, :procedure],
-
-    :latex => [:part, :chapter, :section, :paragraph],
-  }
-
-  attr_reader :nodeTree, :references
-
-  def initialize
-    super
-
-    @boxCipher = Cipher.new
-    @references = []
-    @boxes = Hash.new {|h,k| h[k] = []}
-    @lazyHandlers = {}
-
-
-    # node hierarcy
-
-    @nodeTree = NodeTree.new
-
-    GROUP2TYPES.each_pair do |group, types|
-      next if group == :latex
-
-      types.each do |type|
-        add_node_handler group, type do |node, content, *args|
-          %{
-            <hr style="display: none"/>
-
-            <div class="#{group}">
-              <div class="#{type}" id="#{node.anchor}">
-                #{
-                  if group == :admonition
-                    %{<img src="images/tango/#{type}.png" alt="#{type}" class="icon"/>}
-                  end
-                }
-
-                <p class="title"><a href="##{node.tocAnchor}" class="ref">#{type.to_s.capitalize} #{node.number}</a>. &nbsp; #{node.title.to_html}</p>
-
-                #{content.to_html}
-              </div>
-            </div>
-          }
-        end
-      end
-    end
-
-    add_node_handler :latex, :front_cover do |node, content, *args|
-      %{
-        <hr style="display: none"/>
-
-        <div id="#{node.anchor}" class="front_cover">
-          <h1 class="title"><big>#{node.title.to_html}</big></h1>
-
-          #{content.to_html}
-
-        </div>
-      }
-    end
-
-    add_node_handler :latex, :part do |node, content, *args|
-      %{
-        <hr style="display: none"/>
-
-        <div id="#{node.anchor}" class="part">
-          <h1 class="title">
-            Part <a href="##{node.tocAnchor}" class="ref">#{node.number}</a>
-
-            <br/><br/>
-
-            <big>#{node.title.to_html}</big>
-          </h1>
-
-          #{content.to_html}
-
-        </div>
-      }
-    end
-
-    add_node_handler :latex, :chapter do |node, content, *args|
-      %{
-        <hr style="display: none"/>
-
-        <div id="#{node.anchor}" class="chapter">
-          <h1 class="title">
-            Chapter <a href="##{node.tocAnchor}" class="ref">#{node.latexNumber}</a>
-
-            <br/><br/>
-
-            <big>#{node.title}</big>
-          </h1>
-
-          #{content.to_html}
-        </div>
-      }
-    end
-
-    add_node_handler :latex, :section do |node, content, *args|
-      level = [node.depth, 6].min
-
-      %{
-        <hr style="display: none"/>
-
-        <div id="#{node.anchor}" class="section">
-          <h#{level} class="title">
-            <a href="##{node.tocAnchor}" class="ref">#{node.latexNumber}</a>
-
-            &nbsp;
-
-            #{node.title.to_html}
-          </h#{level}>
-
-          #{content.to_html}
-
-        </div>
-      }
-    end
-
-    add_node_handler :latex, :paragraph do |node, content, *args|
-      %{
-        <div id="#{node.anchor}" class="paragraph">
-          <p class="title">#{node.title.to_html}</p>
-          #{content.to_html}
-        </div>
-      }
-    end
-
-
-    @bibCipher = Cipher.new
-
-    # bibliography items
-    add_node_handler :index, :reference do |node, content, *args|
-      %{
-        <div id="#{node.anchor}" class="reference">
-          <table>
-            <tr>
-              <th>[#{node.number}]</th>
-              <td>#{content.to_html}</td>
-            </tr>
-          </table>
-        </div>
-      }
-    end
-
-    # bibliography items
-    add_handler :footnote do |caller, buffer, content, name|
-      anchor = "ref:#{name}".to_html_anchor
-      index  = @footnotes.length
-      @footnotes << FootNote.new(anchor, name)
-
-      buffer << @bibCipher.encrypt(
-        [
-          %{<div id="#{anchor}">},
-            %{|_. [#{index}]|#{content}|}.to_html,
-          '</div>',
-        ].join
-      )
-    end
-
-    # bibliography citations
-    add_lazy_handler :cite do |target, *args|
-      node = @nodeTree.type2nodes[:reference].find {|n| n.id == target}
-
-      if node
-        words = [
-          %{<a href="##{node.anchor}" class="ref">Reference #{node.number}</a>},
-
-          # extra information about the citation (page #, etc.)
-          *args.map {|s| s.to_html}
-        ]
-
-        "(see #{ words.join(', ') })"
-      else
-        warn "invalid cite to #{target.inspect}"
-        ''
-      end
-    end
-
-    # cross references
-    add_lazy_handler :xref do |aTarget, aTitle|
-      nodes  = @nodeTree.nodes
-      target = nodes.find {|n| n.id == aTarget} || # id has first priority
-               nodes.find {|n| n.anchor == aTarget}
-
-      if target
-        title = aTitle || "#{target.type.to_s.capitalize} #{target.latexNumber || target.number}"
-        %{<a href="##{target.anchor}" class="ref">#{title.to_html}</a>}
-      else
-        warn "invalid xref to #{aTarget.inspect}"
-        ''
-      end
-    end
-  end
-
-  def add_lazy_handler aHandlerName, &aHandler
-    (class << self; self; end).instance_eval do
-      define_method aHandlerName do |*args|
-        token = "#{aHandlerName}#{args.object_id}".digest
-        @lazyHandlers[token] = [aHandler, args]
-        token
-      end
-    end
-  end
-
-  # aNodeType:: name of the command that will trigger the handler
-  # aNodeHandler:: handler that will be triggered by the given command
-  def add_node_handler aNodeGroup, aNodeType, &aNodeHandler #:yields: node, content, *args
-    raise ArgumentError unless block_given?
-
-    if @nodeTree.handlers.key? aNodeType
-      raise "node handler #{aNodeType.inspect} already exists"
-    end
-    @nodeTree.handlers[aNodeType] = aNodeHandler
-
-
-    add_handler aNodeType do |caller, buffer, content, nodeInfo, *args|
-      if @nodeTree.caller2node.key? caller
-        node = @nodeTree.caller2node[caller]
-
-        # collect tree traversal information
-        node.timesSeen += 1
-
-      else # first time we are handling this node
-
-        # parse the arguments given to this handler
-        if nodeInfo.respond_to? :to_hash
-          nodeInfo = nodeInfo.to_hash
-          raise ArgumentError unless nodeInfo.key? :title
-        else
-          nodeInfo = {:title => nodeInfo.to_s, :id => args.shift}
-        end
-
-        # register this node as having been seen
-        node = Node.new nodeInfo.merge(
-          # node info
-          :caller       => caller,
-          :type         => aNodeType,
-          :group        => aNodeGroup,
-          :args         => args,
-
-          # content info
-          :content      => content,
-          :digest       => content.digest,
-          :leadingSpace => (buffer =~ /([ \t]*)\Z/ && $1),
-
-          # traversal info
-          :orderSeen    => @nodeTree.caller2node.keys.length,
-          :timesSeen    => 1
-        )
-        @nodeTree.caller2node[caller] = node
-      end
-
-      buffer << node.digest
-    end
-  end
-
-  # Post-processes the given ERB template result by parsing the document
-  # structure and expanding cross-references, and returns the result.
-  def post_process aResult
-    text = aResult
-
-
-    # build the node tree
-    @nodeTree.build!
-    toc = @nodeTree.table_of_contents
-
-
-    # convert to HTML
-    File.open('text', 'w') {|f| f << text} if $DEBUG
-    html = text.to_html
-    File.open('html', 'w') {|f| f << html} if $DEBUG
-
-
-    @nodeTree.process_input! html, @innerSpace
-
-    # expand cross-references into links to their targets
-    @lazyHandlers.each_pair do |token, (handler, args)|
-      html.gsub! token, handler.call(*args)
-    end
-
-    # expand all citations
-    # html = @bibCipher.decrypt_all(html)
-
-
-    [toc, html]
-  end
-
-
-  ##-----------------------------------------------------------------------
-  # user API
-
-  # Unindents the inner space by the given amount.
-  def unindent aInnerSpace
-    @innerSpace = aInnerSpace
-  end
-
-  #-----------------------------------------------------------------------
-
-  private
-
-  def expand_includes aFilePath
-    input = File.read(aFilePath)
-
-    input.gsub! %r{<doc_proxy_include *(.*?)>} do
-      expand_includes($1)
-    end
-
-    input
-  end
-
-  #-----------------------------------------------------------------------
-
-  class Node < OpenStruct
-    undef id
-    undef type
-  end
-
-  class Cipher < Hash
-    def encrypt aString
-      digest       = aString.digest
-      self[digest] = aString
-      digest
-    end
-
-    def decrypt digest
-      self[digest]
-    end
-
-    # Iteratively decrypts all digest substrings within the given string.
-    def decrypt_all aString
-      temp = self.dup
-      str  = aString.dup
-
-      until temp.empty?
-        cipher = temp.find do |(digest, original)|
-          str.gsub! digest, original
-        end
-
-        raise unless cipher
-        temp.delete cipher[0]
-      end
-
-      str
-    end
-  end
-
-  class NodeTree < Hash
-    attr_reader :caller2node, :group2nodes, :type2nodes, :cipher, :handlers
-
-    def initialize
-      @cipher      = Cipher.new
-      @handlers    = {}
-      @caller2node = {}
-      @type2nodes  = Hash.new {|h,k| h[k] = []}
-      @group2nodes = Hash.new {|h,k| h[k] = []}
-    end
-
-    def nodes
-      @caller2node.values
-    end
-
-    # Evaluates the given string which contains node digests.
-    def process_input! aString, aInnerSpace = nil
-      list = nodes
-
-      # let handlers modify node content
-      list.each do |node|
-        src = node.content
-        dst = @handlers[node.type].call(node, src, *node.args)
-
-        if aInnerSpace
-          space = node.leadingSpace + aInnerSpace
-
-          # add leading space if not present. this will ensure that
-          # lines without any leading space are correctly unindented
-          dst.gsub! %r/^[ \t]*/ do
-            if $&.index(space) == 0
-              $&
-            else
-              space + $&
-            end
-          end
-
-          # remove leading space
-          dst.gsub! %r/^#{space}/, ''
-        end
-
-        # XXX: escape single backslashes because they
-        #      are removed later on for some reason...
-        dst.gsub! %r/\\/, '\&\&'
-
-        node.content = dst
-      end
-
-      # replace all node digests with node content
-      until list.empty?
-        target = list.find do |node|
-          aString.gsub! node.digest, node.content
-        end
-
-        raise unless target
-        list.delete target
-      end
-    end
-
-    # Builds this tree from traversal information.
-    def build!
-      # build the tree
-      self.clear
-      children = []
-      lastDepth = 0
-
-      nodes.sort_by {|n| n.orderSeen}.each do |node|
-        currDepth = node.timesSeen
-
-        # register this node into adjacency list
-        self[node] = [] unless self.key? node
-
-        if lastDepth > currDepth
-          subnodes = children.select {|n| n.timesSeen > currDepth}
-          self[node].concat subnodes
-          children = children - subnodes
-        end
-
-        children << node
-        lastDepth = currDepth
-      end
-
-      if $DEBUG
-        nodes.each do |node|
-          def node.inspect
-            title.inspect
-          end
-        end
-        pp self
-      end
-
-
-      # set depths of all nodes starting from root-level nodes
-      rootNodes = self.keys - self.values.flatten.uniq
-      rootNodes.sort_by {|n| n.orderSeen}.each do |node|
-        set_depth node, 1
-      end
-
-
-      # fill information for later stages
-      idUsage = Hash.new {|h,k| h[k] = []}
-
-      nodes.each do |node|
-        node.id ||= node.title
-        idUsage[node.id] << node
-
-        # forward and reverse anchors from & back to TOC
-        node.anchor    = node.id.to_html_anchor
-        node.tocAnchor = node.object_id.to_s.to_html_anchor
-      end
-
-      idUsage.select {|(k,v)| v.length > 1}.each do |id, nodes|
-        warn "#{nodes.length} nodes have the same identifier: #{id.inspect}"
-      end
-    end
-
-    def table_of_contents
-      toc = '<ul>'
-      prevDepth = 0
-      prevIndex = ''
-
-      @group2nodes[:latex].each do |node|
-        # generate a LaTeX-style index (section number) for the heading
-        depthDiff = (node.depth - prevDepth).abs
-
-        node.latexNumber =
-          if node.depth > prevDepth
-            toc << '<li><ul>' * depthDiff
-
-            s = prevIndex + ('.1' * depthDiff)
-            s.sub(/^\./, '')
-
-          elsif node.depth < prevDepth
-            toc << '</ul></li>' * depthDiff
-
-            s = prevIndex.sub(/(\.\d+){#{depthDiff}}$/, '')
-            s.next
-
-          else
-            prevIndex.next
-          end
-
-        prevDepth = node.depth
-        prevIndex = node.latexNumber
-
-
-        # generate hyperlink for traveling from TOC to heading
-        toc << %{<li>#{node.latexNumber} <a id="#{node.tocAnchor}" href="##{node.anchor}" class="ref">#{node.title.to_html}</a></li>}
-      end
-
-      if prevIndex.empty?
-        toc = nil # there were no headings
-      else
-        toc << '</ul></li>' * prevDepth
-        toc << '</ul>'
-
-        # collapse redundant list elements
-        while toc.gsub! %r{(<li>.*?)</li><li>(<ul>)}, '\1\2'
-        end
-
-        # collapse unnecessary levels
-        while toc.gsub! %r{(<ul>)<li><ul>(.*)</ul></li>(</ul>)}, '\1\2\3'
-        end
-      end
-
-      toc
-    end
-
-    private
-
-    # recursively sets the depth of the given
-    # node and performs linear node numbering
-    def set_depth aNode, aDepth
-      aNode.depth = aDepth
-
-      # set number for boxes (fig 1, fig 2, etc.)
-      ary = @type2nodes[aNode.type]
-      ary << aNode
-      aNode.number = ary.length
-      @group2nodes[aNode.group] << aNode
-
-      self[aNode].each do |child|
-        set_depth child, aDepth + 1
-      end
-    end
-  end
-end

data/doc/lib/erb_content.rb

@@ -1,55 +0,0 @@
-#--
-# Copyright 2006 Suraj N. Kurapati
-# See the file named LICENSE for details.
-
-require 'erb'
-
-# Returns an array containing the current ERB buffer and the content
-# that the given block will append to the buffer when it is invoked.
-#
-# == Example
-# Suppose your ERB template invoked a method with some arguments
-# and some content in a block.  You can pass the block to this
-# method to obtain the content contained within the block.
-#
-## template = ERB.new <<-EOS
-## <% wrap_xml "message" do %>
-##   i love ruby!
-## <% end %>
-## EOS
-#
-# In this case, the ERB template invokes the _wrap_xml_
-# method to wrap some content within a pair of XML tags.
-#
-## def wrap_xml tag, &block
-##   buffer, content = ERB.buffer_and_content(&block)
-##   buffer << "<#{tag}>#{content}</#{tag}>"
-## end
-#
-# When we evaluate the template:
-## puts template.result(binding)
-#
-# we see the following output:
-## <message>
-##   i love ruby!
-## </message>
-#
-def ERB.buffer_and_content
-  raise ArgumentError unless block_given?
-
-  # buffer + content
-  buffer = yield
-  a = buffer.length
-
-  # buffer + content + content
-  yield
-  b = buffer.length
-
-  # buffer + content
-  content = buffer.slice! a..b
-
-  # buffer
-  buffer.slice! -content.length..-1
-
-  [buffer, content]
-end

data/doc/lib/erb_proxy.rb

@@ -1,42 +0,0 @@
-#--
-# Copyright 2006 Suraj N. Kurapati
-# See the file named LICENSE for details.
-
-$: << File.basename(__FILE__)
-require 'erb_content'
-
-class ErbProxy
-  attr_reader :handlers
-
-  def initialize
-    @handlers = {}
-  end
-
-  # Adds a new handler that can be invoked from a ERB
-  # template.  The arguments passed to the handler are:
-  #
-  # 1. unique identifier for the calling location in the ERB template
-  #
-  # 2. buffer containing the evaluated results of the ERB template thus far
-  #
-  # 3. content that was passed to the handler from the ERB template
-  #
-  # 4. variable number of method arguments passed from the ERB template
-  #
-  def add_handler aName, &aHandler # :yields: caller, buffer, content, *args
-    @handlers[aName] = aHandler
-
-    # XXX: using a string because define_method
-    #      does not accept a block until Ruby 1.9
-    instance_eval %{
-      def #{aName} *args, &block
-        if block_given?
-          args = ERB.buffer_and_content(&block).concat(args)
-        else
-          args.unshift '', ''
-        end
-        @handlers[#{aName.inspect}].call(Kernel.caller.first, *args)
-      end
-    }
-  end
-end