RubyGems - erlapi - Versions diffs - 0.1.9 - Mend

erlapi 0.1.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (100) hide show

data/lib/erlapi/generator/template/shtml/resources/panel/index.html ADDED

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+	"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+	<title>layout</title>
+	<link rel="stylesheet" href="../css/reset.css" type="text/css" media="screen" charset="utf-8" />
+	<link rel="stylesheet" href="../css/panel.css" type="text/css" media="screen" charset="utf-8" />
+	<script src="search_index.js" type="text/javascript" charset="utf-8"></script>
+	<script src="tree.js" type="text/javascript" charset="utf-8"></script>
+	<script src="../js/jquery-1.3.2.min.js" type="text/javascript" charset="utf-8"></script>
+	<script src="../js/searchdoc.js" type="text/javascript" charset="utf-8"></script>
+	<script type="text/javascript" charset="utf-8">
+		//<![CDATA[
+	    function placeholder() {
+ 	       if (jQuery.browser.safari) return;
+ 	       $('#search-label').click(function() {
+ 	           $('#search').focus();
+ 	           $('#search-label').hide();
+ 	       });
+ 	       $('#search').focus(function() {
+ 	           $('#search-label').hide();
+            });
+ 	       $('#search').blur(function() {
+ 	           this.value == '' && $('#search-label').show()
+ 	       });
+ 	       $('#search')[0].value == '' && $('#search-label').show();
+	    }
+	   $(function() {
+           placeholder();
+           var panel = new Searchdoc.Panel($('#panel'), search_data, tree, top.frames[1]);
+           $('#search').focus();
+           var s = window.parent.location.search.match(/\?q=([^&]+)/);
+           if (s) {
+               s = decodeURIComponent(s[1]).replace(/\+/g, ' ');
+               if (s.length > 0)
+               {
+                   $('#search').val(s);
+                   panel.search(s, true);
+               }
+           }
+	   })
+		//]]>
+	</script>
+</head>
+<body>
+    <div class="panel panel_tree" id="panel">
+        <div class="header">
+            <div>
+                <label for="search" id="search-label" style="display: none">Search</label>
+                <table>
+                <tr><td>
+                    <input type="Search" placeholder="Search" autosave="searchdoc" results="10" id="search" autocomplete="off"/>
+                </td></tr>
+            </table></div>
+        </div>
+        <div class="tree">
+            <ul>
+            </ul>
+        </div>
+        <div class="result">
+            <ul>
+            </ul>
+        </div>
+    </div>
+</body>
+</html>

data/lib/erlapi/helpers.rb ADDED

@@ -0,0 +1,26 @@
+module Erlapi::Helpers
+  def each_letter_group(methods, &block)
+    group = {:name => '', :methods => []}
+    methods.sort{ |a, b| a.name <=> b.name }.each do |method|
+      gname = group_name method.name
+      if gname != group[:name]
+        yield group unless group[:methods].size == 0
+        group = {
+          :name => gname,
+          :methods => []
+        }
+      end
+      group[:methods].push(method)
+    end
+    yield group unless group[:methods].size == 0
+  end
+protected
+  def group_name name
+    if match = name.match(/^([a-z])/i)
+      match[1].upcase
+    else
+      '#'
+    end
+  end
+end

data/lib/erlapi/merge.rb ADDED

@@ -0,0 +1,217 @@
+require 'optparse'
+require 'pathname'
+require 'fileutils'
+require 'json'
+require 'sdoc/templatable'
+class SDoc::Merge
+  include SDoc::Templatable
+  FLAG_FILE = "created.rid"
+  def initialize()
+    @names = []
+    @urls = []
+    @op_dir = 'doc'
+    @title = ''
+    @directories = []
+    template_dir = RDoc::Generator::SHtml.template_dir('merge')
+		@template_dir = Pathname.new File.expand_path(template_dir)
+  end
+  def merge(options)
+    parse_options options
+		@outputdir = Pathname.new( @op_dir )
+    check_directories
+    setup_output_dir
+    setup_names
+    copy_files
+    copy_docs if @urls.empty?
+    merge_search_index
+    merge_tree
+    generate_index_file
+  end
+  def parse_options(options)
+    opts = OptionParser.new do |opt|
+      opt.banner = "Usage: sdoc-merge [options] directories"
+      opt.on("-n", "--names [NAMES]", "Names of merged repositories. Comma separated") do |v|
+        @names = v.split(',').map{|name| name.strip }
+      end
+      opt.on("-o", "--op [DIRECTORY]", "Set the output directory") do |v|
+        @op_dir = v
+      end
+      opt.on("-t", "--title [TITLE]", "Set the title of merged file") do |v|
+        @title = v
+      end
+      opt.on("-u", "--urls [URLS]", "Paths to merged docs. If you \n" +
+                   "set this files and classes won't be actualy copied to merged build") do |v|
+        @urls = v.split(' ').map{|name| name.strip }
+      end
+    end
+    opts.parse! options
+    @directories = options.dup
+  end
+  def merge_tree
+    tree = []
+    @directories.each_with_index do |dir, i|
+      name = @names[i]
+      url = @urls.empty? ? name : @urls[i]
+      filename = File.join dir, RDoc::Generator::SHtml::TREE_FILE
+      data = open(filename).read.sub(/var tree =\s*/, '')
+      subtree = JSON.parse data, :max_nesting => 35
+      item = [
+        name,
+        url + '/' + extract_index_path(dir),
+        '',
+        append_path(subtree, url)
+      ]
+      tree << item
+    end
+    dst = File.join @op_dir, RDoc::Generator::SHtml::TREE_FILE
+    FileUtils.mkdir_p File.dirname(dst)
+    File.open(dst, "w", 0644) do |f|
+      f.write('var tree = '); f.write(tree.to_json)
+    end
+  end
+  def append_path subtree, path
+    subtree.map do |item|
+      item[1] = path + '/' + item[1] unless item[1].empty?
+      item[3] = append_path item[3], path
+      item
+    end
+  end
+  def merge_search_index
+    items = []
+    @indexes = {}
+    @directories.each_with_index do |dir, i|
+      name = @names[i]
+      url = @urls.empty? ? name : @urls[i]
+      filename = File.join dir, RDoc::Generator::SHtml::SEARCH_INDEX_FILE
+      data = open(filename).read.sub(/var search_data =\s*/, '')
+      subindex = JSON.parse data, :max_nesting => 35
+      @indexes[name] = subindex
+      searchIndex = subindex["index"]["searchIndex"]
+      longSearchIndex = subindex["index"]["longSearchIndex"]
+      subindex["index"]["info"].each_with_index do |info, j|
+        info[2] = url + '/' + info[2]
+        info[6] = i
+        items << {
+          :info => info,
+          :searchIndex => searchIndex[j],
+          :longSearchIndex => name + ' ' + longSearchIndex[j]
+        }
+      end
+    end
+    items.sort! do |a, b|
+      # type (class/method/file) or name or doc part or namespace
+      [a[:info][5], a[:info][0], a[:info][6], a[:info][1]] <=> [b[:info][5], b[:info][0], b[:info][6], b[:info][1]]
+    end
+    index = {
+      :searchIndex => items.map{|item| item[:searchIndex]},
+      :longSearchIndex => items.map{|item| item[:longSearchIndex]},
+      :info => items.map{|item| item[:info]}
+    }
+    search_data = {
+      :index => index,
+      :badges => @names
+    }
+    dst = File.join @op_dir, RDoc::Generator::SHtml::SEARCH_INDEX_FILE
+    FileUtils.mkdir_p File.dirname(dst)
+    File.open(dst, "w", 0644) do |f|
+      f.write('var search_data = '); f.write(search_data.to_json)
+    end
+  end
+  def extract_index_path dir
+    filename = File.join dir, 'index.html'
+    content = File.open(filename) { |f| f.read }
+    match = content.match(/<frame\s+src="([^"]+)"\s+name="docwin"/mi)
+    if match
+      match[1]
+    else
+      ''
+    end
+  end
+  def generate_index_file
+    templatefile = @template_dir + 'index.rhtml'
+    outfile      = @outputdir + 'index.html'
+    url          = @urls.empty? ? @names[0] : @urls[0]
+    index_path   = url + '/' + extract_index_path(@directories[0])
+    render_template templatefile, binding(), outfile
+  end
+  def setup_names
+    unless @names.size > 0
+      @directories.each do |dir|
+        name = File.basename dir
+        name = File.basename File.dirname(dir) if name == 'doc'
+        @names << name
+      end
+    end
+  end
+  def copy_docs
+    @directories.each_with_index do |dir, i|
+      name = @names[i]
+      index_dir = File.dirname(RDoc::Generator::SHtml::TREE_FILE)
+      FileUtils.mkdir_p(File.join(@op_dir, name))
+      Dir.new(dir).each do |item|
+        if File.directory?(File.join(dir, item)) && item != '.' && item != '..' && item != index_dir
+          FileUtils.cp_r File.join(dir, item), File.join(@op_dir, name, item), :preserve => true
+        end
+      end
+    end
+  end
+  def copy_files
+    dir = @directories.first
+    Dir.new(dir).each do |item|
+      if item != '.' && item != '..' && item != RDoc::Generator::SHtml::FILE_DIR && item != RDoc::Generator::SHtml::CLASS_DIR
+        FileUtils.cp_r File.join(dir, item), @op_dir, :preserve => true
+      end
+    end
+  end
+  def setup_output_dir
+    if File.exists? @op_dir
+      error "#{@op_dir} allready exists"
+    end
+    FileUtils.mkdir_p @op_dir
+  end
+  def check_directories
+    @directories.each do |dir|
+      unless File.exists?(File.join(dir, FLAG_FILE)) &&
+      File.exists?(File.join(dir, RDoc::Generator::SHtml::TREE_FILE)) &&
+      File.exists?(File.join(dir, RDoc::Generator::SHtml::SEARCH_INDEX_FILE))
+        error "#{dir} does not seem to be an sdoc directory"
+      end
+    end
+  end
+  ##
+  # Report an error message and exit
+  def error(msg)
+    raise RDoc::Error, msg
+  end
+end

data/lib/erlapi/parser.rb ADDED

@@ -0,0 +1,134 @@
+require 'nokogiri'
+module Erlapi::Parser
+  class Base
+    attr_accessor :src_dir, :template_dir, :files, :modules, :entities_coder
+    def initialize(src_dir = nil)
+      self.files = []
+      self.modules = {}
+      self.src_dir = Pathname.new(src_dir || File.join(File.dirname(__FILE__), '..', 'src'))
+      self.template_dir = File.join(File.dirname(__FILE__), 'templates')
+    end
+    def parse
+      files.each do |file|
+        puts "Parsing #{file}"
+        doc = Nokogiri::XML(File.read(file))
+        mod = Erlapi::Parser::Module.new(self, doc)
+        self.modules[mod.title] = mod if mod.valid
+      end
+    end
+    def inner_xml(node)
+      node.is_a?(Nokogiri::XML::NodeSet) ? node.collect{|j| j.children.to_xml}.join('') : node.children.to_xml
+    end
+    def special_tags(str)
+      str.gsub!(/<c>(.*?)<\/c>/mi, '<tt>\1</tt>')
+      str.gsub!(/<code.*?>(.*?)<\/code>/mi, '<pre>\1</pre>')
+      str.gsub!(/<v.*?>(.*?)<\/v>/mi, '<b>\1</b><br/>')
+      str.gsub!(/<input.*?>(.*?)<\/input>/mi, '<tt>\1</tt><br/>')
+      str
+    end
+    def prepare_string(str)
+      str.gsub(/\\\\/, '\\')
+    end
+    def files
+      load_files(src_dir.realpath)
+      @files
+    end
+    def load_files(dir_path)
+      dir = Dir.new(dir_path)
+      dir.each do |file_name|
+        full_path = File.join(dir.path, file_name)
+        if file_name != '.' && file_name != '..'
+          if File.directory?(full_path)
+            load_files(full_path)
+          else
+            @files << full_path if File.extname(file_name) == '.xml'
+          end
+        end
+      end
+      dir.close
+    end
+  end
+  class Module
+    attr_accessor :parser, :title, :summary, :desc, :datatypes, :funcs, :sections, :valid, :doc
+    def initialize(parser, doc)
+      self.doc = doc
+      self.parser = parser
+      self.title = doc.css('module').inner_html
+      self.summary = doc.css('modulesummary').inner_html || ''
+      if self.title && self.title != ''
+        self.valid = true
+      else
+        self.valid = false
+      end
+      if valid
+        define_desc
+        define_sections
+        define_funcs
+      end
+    end
+    def define_desc
+      self.desc = self.parser.special_tags(self.parser.inner_xml(doc.css('description')))
+    end
+    def define_sections
+      self.sections = []
+      doc.css('section').each do |node|
+        self.sections << Erlapi::Parser::Section.new(self, node)
+      end
+    end
+    def define_funcs
+      self.funcs = []
+      doc.css('funcs func').each do |node|
+        func = Erlapi::Parser::Func.new(self, node)
+        self.funcs << func if func.short_name
+      end
+    end
+  end
+  class Func
+    attr_accessor :p_module, :short_name, :names, :summary, :types, :desc, :ref, :short_names
+    def initialize(p_module, node)
+      self.p_module = p_module
+      self.names = node.css('name').map {|v| v.inner_html}
+      if self.names
+        self.short_names = self.names.map { |n| n.match(/([\w\d_-]*)\(/) ? $~[1] : nil }.compact.uniq
+        self.short_name = self.short_names.first if self.short_names
+      end
+      self.ref = self.names.first.gsub(/[^\w]/, '')
+      self.summary = parser.inner_xml(node.css('fsummary'))
+      self.types = parser.special_tags(parser.inner_xml(node.css('type')))
+      self.desc = parser.special_tags(parser.inner_xml(node.css('desc')))
+    end
+    def parser
+      self.p_module.parser
+    end
+  end
+  class Section
+    attr_accessor :p_module, :name, :desc
+    def initialize(p_module, node)
+      self.p_module = p_module
+      self.name = node.css('title').inner_html
+      self.desc = parser.special_tags(parser.inner_xml(node))
+    end
+    def parser
+      self.p_module.parser
+    end
+  end
+end