prepor-erlapi 0.1.8

data/lib/erlapi/generator.rb

@@ -0,0 +1,194 @@
+require 'pathname'
+class Erlapi::Generator
+  attr_accessor :data, :output_dir, :source_dir
+  
+  GENERATOR_DIRS = [File.join('sdoc', 'generator'), File.join('rdoc', 'generator')]
+  
+  # Used in js to reduce index sizes
+  TYPE_CLASS  = 1
+  TYPE_METHOD = 2
+  TYPE_FILE   = 3
+  
+  
+  TEMPLATE_DIR = Pathname.new(File.dirname(__FILE__)) + 'templates' + 'html' + 'shtml'
+  
+  
+  FILE_DIR = 'files'
+  CLASS_DIR = 'classes'
+  
+  RESOURCES_DIR = 'resources'
+  
+  
+  include ERB::Util
+  include Erlapi::Templatable
+  include Erlapi::Helpers
+  
+  def initialize(options = {})    
+    self.output_dir = Pathname.new(options[:output_dir])
+    
+    self.output_dir.mkdir if !self.output_dir.directory?      
+      
+    self.data = options[:data]
+    define_paths
+  end
+  
+  def define_paths
+    @tree_file = output_dir + 'panel' + 'tree.js'
+    @search_index_file = output_dir + 'panel' + 'search_index.js'
+  end
+  
+  def generate(options = {})
+    @options = options
+    copy_resources
+    generate_search_index
+    generate_class_tree
+    generate_class_files
+    generate_index_file
+  end
+  
+  ### Copy all the resource files to output dir
+  def copy_resources
+    resources_path = File.join(TEMPLATE_DIR, RESOURCES_DIR) + '/.'
+		debug_msg "Copying #{resources_path}/** to #{output_dir}/**"
+    FileUtils.cp_r resources_path.to_s, output_dir.to_s, :preserve => true
+  end
+  
+  ### Generate a documentation file for each class
+	def generate_class_files
+		debug_msg "Generating class documentation in #{output_dir}"
+    templatefile = TEMPLATE_DIR + 'class.rhtml'
+
+		self.data.each do |mod_name, mod|
+		  if mod_name
+  			debug_msg "  working on %s" % [ mod.title]
+  			outfile     = output_dir + (mod.title + '.html')
+        # rel_prefix  = OUTPUT_DIR.relative_path_from( outfile.dirname )
+      
+  			debug_msg "  rendering #{outfile}"
+  			self.render_template( templatefile, binding(), outfile )
+  		end
+		end
+	end
+	
+	### Create index.html with frameset
+	def generate_index_file
+		debug_msg "Generating index file in #{output_dir}"
+    templatefile = TEMPLATE_DIR + 'index.rhtml'
+    outfile      = output_dir + 'index.html'
+	  index_path = self.data.to_a.first[1].title + '.html'
+	  self.render_template( templatefile, binding(), outfile )
+	end
+	
+	### Create class tree structure and write it as json
+  def generate_class_tree
+    debug_msg "Generating class tree"    
+    tree = self.data.map { |mod_name, mod| [mod_name, mod_name + '.html', '', []] }.sort{ |a, b| a[0] <=> b[0] }
+    debug_msg "  writing class tree to %s" % @tree_file
+    File.open(@tree_file, "w", 0644) do |f|
+      f.write('var tree = '); f.write(tree.to_json)
+    end
+  end
+  
+  def generate_search_index
+    debug_msg "Generating search index"
+    
+    index = {
+      :searchIndex => [],
+      :longSearchIndex => [],
+      :info => []
+    }
+    
+    add_class_search_index(index)
+    add_method_search_index(index)
+    
+    debug_msg "  writing search index to %s" % @search_index_file
+    data = {
+      :index => index
+    }
+    File.open(@search_index_file, "w", 0644) do |f|
+      f.write('var search_data = '); f.write(data.to_json)
+    end
+  end
+  
+  
+  ### Add classes to search +index+ array
+  def add_class_search_index(index)
+    debug_msg "  generating class search index"
+    
+    self.data.each do |mod_name, mod|      
+      index[:searchIndex].push( search_string(mod.title) )
+      index[:longSearchIndex].push( search_string(mod.title) )
+      index[:info].push([
+        mod.title,
+        '',
+        mod.title + '.html',
+        '',       
+        snippet(mod.summary),
+        TYPE_CLASS
+      ])
+    end
+  end
+  
+  ### Add methods to search +index+ array
+  def add_method_search_index(index)
+    debug_msg "  generating method search index"
+    
+    list = self.data.map { |mod_name, mod| 
+      mod.funcs
+    }.flatten
+    
+    list.each do |func|
+      func.short_names.each do |func_name|
+        index[:searchIndex].push( search_string(func.p_module.title + ':' + func_name) + '()' )
+        index[:longSearchIndex].push(search_string(func_name))
+        index[:info].push([
+          func_name, 
+          func.p_module.title + ':' + func_name,
+          func.p_module.title + '.html#' + func.ref,
+          '',        
+          snippet(func.summary),
+          TYPE_METHOD
+        ])
+      end
+    end
+  end
+  
+  
+  
+  ### Build search index key
+  def search_string(string)
+    string ||= ''
+    string.downcase.gsub(/\s/,'')
+  end
+  
+  def snippet(str)
+    str ||= ''
+    if str =~ /^(?>\s*)[^\#]/
+      content = str
+    else
+      content = str.gsub(/^\s*(#+)\s*/, '')
+    end
+    
+    content = content.sub(/^(.{100,}?)\s.*/m, "\\1").gsub(/\r?\n/m, ' ')
+    
+    begin
+      content.to_json
+    rescue # might fail on non-unicode string
+      begin
+        content = Iconv.conv('latin1//ignore', "UTF8", content) # remove all non-unicode chars
+        content.to_json
+      rescue
+        content = '' # something hugely wrong happend
+      end
+    end
+    content
+  end
+  
+  ### Output progress information if debugging is enabled
+	def debug_msg( *msg )
+		return unless $DEBUG_DOC
+		$stderr.puts( *msg )
+	end
+	
+	
+end

data/lib/erlapi/helpers.rb

@@ -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

@@ -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

@@ -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