RubyGems - erlapi - Versions diffs - 0.1.9 - Mend

erlapi 0.1.9

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