dnote 0.8

data/MANIFEST

@@ -0,0 +1,17 @@
+README.rdoc
+bin/dnote
+lib/dnote
+lib/dnote.rb
+lib/dnote/notes.rb
+lib/dnote/template
+lib/dnote/template/index.html
+lib/dnote/template/notes.rdoc
+lib/dnote/template/notes.xml
+meta/contact
+meta/package
+meta/project
+meta/released
+meta/repository
+meta/summary
+meta/title
+meta/version

data/README.rdoc

@@ -0,0 +1,50 @@
+= D'Note
+
+* http://proutils.github.com/dnote
+* http://github.com/proutils/dnote
+
+
+== DESCRIPTION
+
+Extract developement notes from source code and make some pretty RDoc and/or HTML
+formatted files out of them.
+
+
+== SYNOPSIS
+
+Developer notes it the source code must be formate as follows: 
+
+  # TYPE: description ...
+  #       ... cont ...
+
+All notes must be separated by a blank line. Eg.
+
+  # TYPE: description ...
+  # 
+  # TYPE: description ...
+
+Without the blank line the second note will be taken to be part of the first.
+Any description that takes up more than one line must remain flush to the left
+margin (if the first line is flush to the left margin too) b/c RDoc will mistake
+of formatting the remaining lines as a +pre+ block it if is not. So...
+
+  # TYPE: ... description ...
+  # continue ...
+
+Alternately the whole note can be a +pre+ block by indenting them. Then the
+layout if freed-up.
+
+  # This is a description of something...
+  #
+  #   TYPE: description ...
+  #         continued ...
+
+
+== COPYRIGHTS
+
+(GPL Licensed)
+
+Copyright (c) 2006, 2009 Thomas Sawyer
+
+[INSERT NOTICE HERE]
+

data/bin/dnote

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'dnote'
+
+options = {}
+
+opts = OptionParser.new do |opt|
+
+  opt.banner = "Usage: dnote [OPTIONS] path1 [path2 ...]"
+
+  opt.on("--label", "debug and verbose modes combined") do |lbl|
+    options[:labels] ||= []
+    options[:labels] << lbl
+  end
+
+  opt.on("--output", "-o [DIR]", "folder to store output") do |out|
+    options[:output] = out
+  end
+
+  opt.on("--debug", "debug mode") do
+    $DEBUG = true
+  end
+
+  opt.on("--verbose", "-v", "verbose mode") do
+    options[:verbose] = true
+  end
+
+  opt.on("--quiet", "-q", "surpress output") do
+    options[:quiet] = true
+  end
+
+  opt.on("--noop", "-n", "pretend mode") do
+    options[:quiet] = true
+  end
+
+  opt.on("--dryrun", "noop and verbose modes combined") do
+    options[:verbose] = true
+    options[:noop] = true
+  end
+
+  opt.on("--trace", "debug and verbose modes combined") do
+    $DEBUG = true
+    options[:verbose] = true
+  end
+
+  opt.on_tail('--help', '-h', "show this help information") do
+    puts self
+    exit
+  end
+
+end
+
+opts.parse!
+
+paths = ARGV.dup
+dnote = DNote.new(paths, options)
+dnote.document
+

data/lib/dnote.rb

@@ -0,0 +1,10 @@
+require 'dnote/notes'
+
+module DNote
+  VERSION = "0.8"  #:till: VERSION = "<%= version %>"
+
+  def self.new(*args)
+    Notes.new(*args)
+  end
+end
+

data/lib/dnote/notes.rb

@@ -0,0 +1,394 @@
+require 'rexml/text'
+require 'pathname'
+require 'erb'
+#require 'reap/project/scm'
+
+module DNote
+
+  # = Developer Notes
+  #
+  # This class goes through you source files and compiles
+  # an list of any labeled comments. Labels are single word
+  # prefixes to a comment ending in a colon.
+  #
+  # By default the labels supported are TODO, FIXME, OPTIMIZE and DEPRECATE.
+  #
+  # Output is a set of files in XML and RDoc's simple
+  # markup format.
+  #
+  #   TODO: Add ability to read header notes. They oftern
+  #         have a outline format, rather then the single line.
+  #
+  #   TODO: Need good CSS file.
+  #
+  #   TODO: Need XSL?
+  #
+  class Notes
+
+    # Default note labels to look for in source code.
+    DEFAULT_LABELS = ['TODO', 'FIXME', 'OPTIMIZE', 'DEPRECATE']
+
+    #
+    DEFAULT_OUTPUT = Pathname.new('log/notes')
+
+    #
+    attr_accessor :title
+
+    # Non-Operative
+    attr_accessor :noop
+
+    # Verbose
+    attr_accessor :verbose
+
+    # Paths to search.
+    attr_accessor :paths
+
+    # Labels to document. Defaults are: TODO, FIXME, OPTIMIZE and DEPRECATE.
+    attr_accessor :labels
+
+    # Directory to save output. Defaults to standard log directory.
+    attr_accessor :output
+
+    # Format (xml, html, text).
+    # TODO: HTML format is not usable yet.
+    #attr_accessor :format
+
+    #
+    def initialize(paths, options={})
+      initialize_defaults
+
+      if paths.empty?
+        if file = File.exist?('meta/loadpath')
+          paths = YAML.load(File.new(file)).to_list
+          paths = Array === paths ? paths : paths.split(/\s+/)
+        elsif file = File.exist?('lib')
+          paths = ['lib']
+        else
+          paths = ['**/*.rb']
+        end
+      end
+
+      @paths = paths
+
+      options.each do |k, v|
+        __send__("#{k}=", v)
+      end
+    end
+
+    #
+    def initialize_defaults
+      @paths    = ['lib']
+      @output   = DEFAULT_OUTPUT
+      @labels   = DEFAULT_LABELS
+      @title    = "Developer's Notes"
+      #@format   = 'xml'
+    end
+
+    #
+    def noop?
+      @noop
+    end
+
+    #
+    def verbose?
+      @verbose
+    end
+
+    #
+    def notes
+      @notes
+    end
+
+    #
+    def counts
+      @counts
+    end
+
+    #
+    def templates
+      Dir[File.join(File.dirname(__FILE__), 'template/*')]
+    end
+
+    # Scans source code for developer notes and writes them to 
+    # well organized files.
+    #
+    def document
+      paths    = self.paths
+      output   = self.output
+
+      parse
+
+      #paths  = paths.to_list
+
+      #labels = labels.split(',') if String === labels
+      #labels = [labels].flatten.compact
+
+      #records, counts = extract(labels, loadpath)
+      #records = organize(records)
+
+      #case format.to_s
+      #when 'rdoc', 'txt', 'text'
+      #  text = format_rd(records)
+      #else
+      #  text = format_xml(records)
+      #end
+
+      if notes.empty?
+        puts "No #{labels.join(', ')} notes."
+      else
+        templates.each do |template|
+          erb  = ERB.new(File.read(template))
+          text = erb.result(binding)
+          #text = format_notes(notes, format)
+          file = write(File.basename(template), text)
+          #file = file #Pathname.new(file).relative_path_from(Pathname.pwd) #project.root
+          puts "Updated #{file}"
+        end
+        puts(counts.map{|l,n| "#{n} #{l}s"}.join(', '))
+      end
+    end
+
+    # Reset output directory, marking it as out-of-date.
+    def reset
+      if File.directory?(output)
+        File.utime(0,0,output)
+        puts "marked #{output}"
+      end
+    end
+
+    # Remove output directory.
+    def clean
+      if File.directory?(output)
+        fu.rm_r(output)
+        puts "removed #{output}"
+      end
+    end
+
+    #
+    def labels=(labels)
+      @labels = (
+        case labels
+        when String
+          labels.split(/[:;,]/)
+        else
+          labels = [labels].flatten.compact.uniq
+        end
+      )
+    end
+
+    #
+    def output=(output)
+      raise "output cannot be root" if File.expand_path(output) == "/"
+      @output = Pathname.new(output)
+    end
+
+  private
+
+    # Gather and count notes. This returns two elements,
+    # a hash in the form of label=>notes and a counts hash.
+    #
+    def parse
+      #
+      files = self.paths.map do |path|
+        if File.directory?(path)
+          Dir.glob(File.join(path, '**/*'))
+        else
+          Dir.glob(path)
+        end
+      end.flatten.uniq
+
+      #
+      records, counts = [], Hash.new(0)
+
+      # iterate through files extracting notes
+      files.each do |fname|
+        next unless File.file?(fname)
+        #next unless fname =~ /\.rb$/      # TODO should this be done?
+        File.open(fname) do |f|
+          line_no, save, text = 0, nil, nil
+          while line = f.gets
+            line_no += 1
+            labels.each do |label|
+              if line =~ /^\s*#\s*#{Regexp.escape(label)}[:]?\s*(.*?)$/
+                file = fname
+                text = ''
+                save = {'label'=>label,'file'=>file,'line'=>line_no,'note'=>text}
+                records << save
+                counts[label] += 1
+              end
+            end
+            if text
+              if line =~ /^\s*[#]{0,1}\s*$/ or line !~ /^\s*#/ or line =~ /^\s*#[+][+]/
+                text.strip!
+                text = nil
+                #records << save
+              else
+                text << line.gsub(/^\s*#\s*/,'')
+              end
+            end
+          end
+        end
+      end
+      # organize the notes
+      notes = organize(records)
+      #
+      @notes, @counts = notes, counts
+    end
+
+    # Organize records in heirarchical form.
+    #
+    def organize(records)
+      orecs = {}
+      records.each do |record|
+        label = record['label']
+        file  = record['file']
+        line  = record['line']
+        note  = record['note'].rstrip
+        orecs[label] ||= {}
+        orecs[label][file] ||= []
+        orecs[label][file] << [line, note]
+      end
+      orecs
+    end
+
+    #
+    #def format_notes(notes, type=:rdoc)
+    #  send("format_#{type}", notes)
+    #end
+
+    # Format notes in XML format.
+    #
+    def notes_xml
+      xml = []
+      xml << "<notes>"
+      notes.each do |label, per_file|
+        xml << %[<set label="#{label}">]
+        per_file.each do |file, line_notes|
+          xml << %[<file src="#{file}">]
+          line_notes.sort!{ |a,b| a[0] <=> b[0] }
+          line_notes.each do |line, note|
+            note = REXML::Text.normalize(note)
+            xml << %[<note line="#{line}" type="#{label}">#{note}</note>]
+          end
+          xml << %[</file>]
+        end
+        xml << %[</set>]
+      end
+      xml << "</notes>"
+      return xml.join("\n")
+    end
+
+    # Format notes in RDoc format.
+    #
+    def notes_rdoc
+      out = []
+      out << "= Development Notes"
+      notes.each do |label, per_file|
+        out << %[\n== #{label}]
+        per_file.each do |file, line_notes|
+          out << %[\n=== file://#{file}]
+          line_notes.sort!{ |a,b| a[0] <=> b[0] }
+          line_notes.each do |line, note|
+            out << %[* #{note} (#{line})]
+          end
+        end
+      end
+      return out.join("\n")
+    end
+
+    # HTML format.
+    #
+    def notes_html
+      xml = []
+      xml << %[<div class="notes">]
+      notes.each do |label, per_file|
+        xml << %[<h2>#{label}</h2>\n<ol class="set #{label.downcase}">]
+        per_file.each do |file, line_notes|
+          xml << %[<li><h3><a href="#{file}">#{file}</a></h3><ol class="file" href="#{file}">]
+          line_notes.sort!{ |a,b| a[0] <=> b[0] }
+          line_notes.each do |line, note|
+            note = REXML::Text.normalize(note)
+            xml << %[<li class="note #{label.downcase}" ref="#{line}">#{note} <sup>#{line}</sup></li>]
+          end
+          xml << %[</ol></li>]
+        end
+        xml << %[</div>]
+      end
+      xml << "</div>"
+      return xml.join("\n")
+    end
+
+    # Save notes.
+    #
+    def write(file, text)
+      file = output + file
+      fu.mkdir_p(output)
+      File.open(file, 'w') { |f| f << text } unless noop?
+      file
+    end
+
+    #
+    def fu
+      @fu ||= (
+        if noop? and verbose?
+          FileUtils::DryRun
+        elsif noop
+          FileUtils::Noop
+        elsif verbose
+          FileUtils::Verbose
+        else
+          FileUtils
+        end
+      )
+    end
+
+  end
+
+end
+
+  #     out = ''
+  #
+  #     case format
+  #     when 'yaml'
+  #       out << records.to_yaml
+  #     when 'list'
+  #       records.each do |record|
+  #         out << "* #{record['note']}\n"
+  #       end
+  #     else #when 'rdoc'
+  #       labels.each do |label|
+  #         recs = records.select{ |r| r['label'] == label }
+  #         next if recs.empty?
+  #         out << "\n= #{label}\n"
+  #         last_file = nil
+  #         recs.sort!{ |a,b| a['file'] <=> b['file'] }
+  #         recs.each do |record|
+  #           if last_file != record['file']
+  #             out << "\n"
+  #             last_file = record['file']
+  #             out << "file://#{record['file']}\n"
+  #           end
+  #           out << "* #{record['note'].rstrip} (#{record['line']})\n"
+  #         end
+  #       end
+  #       out << "\n---\n"
+  #       out << counts.collect{|l,n| "#{n} #{l}s"}.join(' ')
+  #       out << "\n"
+  #     end
+
+  #     # List TODO notes. Same as notes --label=TODO.
+  #
+  #     def todo( options={} )
+  #       options = options.to_openhash
+  #       options.label = 'TODO'
+  #       notes(options)
+  #     end
+  #
+  #     # List FIXME notes.  Same as notes --label=FIXME.
+  #
+  #     def fixme( options={} )
+  #       options = options.to_openhash
+  #       options.label = 'FIXME'
+  #       notes(options)
+  #     end
+

data/lib/dnote/template/index.html

@@ -0,0 +1,30 @@
+<html>
+<head>
+  <title><%= title %></title>
+  <style>
+    body { margin: 0; padding: 0; }
+    .main {
+      width: 800px;
+      margin: 0 auto;
+      border: 1px solid #ccc;
+      padding: 0 20px 20px 20px;
+    }
+    h1 { margin: 25px 0; }
+    h2,h3,h4 { margin: 5px 0; padding: 0; color: 880044; }
+    h3 { color: 004488; }
+    h4 { color: 888844; }
+    ul { margin: 0; padding: 0; text-align: left; }
+    li { margin: 0; padding: 0; text-align: left; }
+  </style>
+</head>
+<body>
+<div class="main">
+
+<h1><%= title %></h1>
+
+<%= notes_html %>
+
+</div>
+</boby>
+</html>
+

data/lib/dnote/template/notes.rdoc

@@ -0,0 +1 @@
+<%= notes_rdoc %>

data/lib/dnote/template/notes.xml

@@ -0,0 +1 @@
+<%= notes_xml %>

data/meta/contact

@@ -0,0 +1 @@
+http://googlegroups.com/group/proutils

data/meta/package

@@ -0,0 +1 @@
+dnote

data/meta/project

@@ -0,0 +1 @@
+proutils

data/meta/released

@@ -0,0 +1 @@
+2009-10-06

data/meta/repository

@@ -0,0 +1 @@
+git://github.com/proutils/dnote.git

data/meta/summary

@@ -0,0 +1 @@
+Extract developer notes from source code.

data/meta/title

@@ -0,0 +1 @@
+D'Note

data/meta/version

@@ -0,0 +1 @@
+0.8

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: dnote
+version: !ruby/object:Gem::Version 
+  version: "0.8"
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: |-
+  Extract developement notes from source code and make some pretty RDoc and/or HTML
+  formatted files out of them.
+email: http://googlegroups.com/group/proutils
+executables: 
+- dnote
+extensions: []
+
+extra_rdoc_files: 
+- MANIFEST
+- README.rdoc
+files: 
+- README.rdoc
+- bin/dnote
+- lib/dnote.rb
+- lib/dnote/notes.rb
+- lib/dnote/template/index.html
+- lib/dnote/template/notes.rdoc
+- lib/dnote/template/notes.xml
+- meta/contact
+- meta/package
+- meta/project
+- meta/released
+- meta/repository
+- meta/summary
+- meta/title
+- meta/version
+- MANIFEST
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --title
+- dnote api
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dnote
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Extract developer notes from source code.
+test_files: []
+