mvz-dnote 1.7.2 → 1.10.0

data/lib/dnote/notes.rb

@@ -1,8 +1,10 @@
-require 'pathname'
-require 'dnote/note'
+# frozen_string_literal: true
 
-module DNote
+require "pathname"
+require "dnote/note"
+require "dnote/notes_collection"
 
+module DNote
   # = Developer Notes
   #
   # This class goes through you source files and compiles a list
@@ -17,70 +19,45 @@ module DNote
   #         have a outline format, rather then the single line.
   #++
   class Notes
-    include Enumerable
-
     # Default paths (all ruby scripts).
-    DEFAULT_PATHS  = ["**/*.rb"]
+    DEFAULT_PATHS = ["**/*.rb"].freeze
 
     # Default note labels to look for in source code. (NOT CURRENTLY USED!)
-    DEFAULT_LABELS = ['TODO', 'FIXME', 'OPTIMIZE', 'THINK', 'DEPRECATE']
+    DEFAULT_LABELS = %w[TODO FIXME OPTIMIZE THINK DEPRECATE].freeze
 
     # Files to search for notes.
-    attr_accessor :files
+    attr_reader :files
 
     # Labels to document. Defaults are: +TODO+, +FIXME+, +OPTIMIZE+ and +DEPRECATE+.
-    attr_accessor :labels
+    attr_reader :labels
 
     # Require label colon? Default is +true+.
-    attr_accessor :colon
+    attr_reader :colon
 
     # Specific remark marker (+nil+ for auto).
-    attr_accessor :marker
+    attr_reader :marker
 
     # Link template.
-    attr_accessor :url
+    attr_reader :url
 
     # Number of lines of context to show.
-    attr_accessor :context
+    attr_reader :context
 
     # New set of notes for give +files+ and optional special labels.
-    def initialize(files, options={})
-      @files   = [files].flatten
-      @labels  = [options[:labels] || DEFAULT_LABELS].flatten.compact
-      @colon   = options[:colon].nil? ? true : options[:colon]
-      @marker  = options[:marker] #|| '#'
-      @url     = options[:url]
+    def initialize(files, options = {})
+      @files = [files].flatten
+      @labels = [options[:labels] || DEFAULT_LABELS].flatten.compact
+      @colon = options[:colon].nil? ? true : options[:colon]
+      @marker = options[:marker]
+      @url = options[:url]
       @context = options[:context] || 0
-
-      @remark  = {}
+      @remark = {}
 
       parse
     end
 
-    # Array of notes.
-    def notes
-      @notes
-    end
-
-    # Notes counts by label.
-    def counts
-      @counts ||= (
-        h = {}
-        by_label.each do |label, notes|
-          h[label] = notes.size
-        end
-        h
-      )
-    end
-
-    # Iterate through notes.
-    def each(&block)
-      notes.each(&block)
-    end
-
-    # No notes?
-    def empty?
-      notes.empty?
+    def notes_collection
+      @notes_collection ||= NotesCollection.new(@notes)
     end
 
     # Gather notes.
@@ -90,47 +67,45 @@ module DNote
     def parse
       records = []
       files.each do |fname|
-        next unless File.file?(fname)
-        #next unless fname =~ /\.rb$/      # TODO: should this be done?
-        mark = remark(fname)
-        lineno, note, text, capt = 0, nil, nil, nil
-        File.readlines(fname).each do |line|
-          #while line = f.gets
-            lineno += 1
-            note = match(line, lineno, fname)
-            if note
-              #file = fname
-              text = note.text
-              capt = note.capture
-              #note = {'label'=>label,'file'=>file,'line'=>line_no,'note'=>text}
-              records << note
-            else
-              if text
-                case line
-                when /^\s*#{mark}+\s*$/, /^\s*#{mark}\-\-/, /^\s*#{mark}\+\+/
-                  text.strip!
-                  text = nil
-                when /^\s*#{mark}/
-                  if text[-1,1] == "\n"
-                    text << line.gsub(/^\s*#{mark}\s*/,'')
-                  else
-                    text << "\n" << line.gsub(/^\s*#{mark}\s*/,'')
-                  end
-                else
-                  text.strip!
-                  text = nil
-                end
-              else
-                if line !~ /^\s*#{mark}/
-                  capt << line if capt && capt.size < context
-                end
-              end
-            end
-          #end
-        end
+        records += parse_file(fname)
       end
 
-      @notes  = records.sort
+      @notes = records.sort
+    end
+
+    def parse_file(fname)
+      return [] unless File.file?(fname)
+
+      records = []
+      mark = remark(fname)
+      lineno = 0
+      note = nil
+      text = nil
+      capt = nil
+      File.readlines(fname).each do |line|
+        lineno += 1
+        note = match(line, lineno, fname)
+        if note
+          text = note.text
+          capt = note.capture
+          records << note
+        elsif text
+          case line
+          when /^\s*#{mark}+\s*$/, /^\s*#{mark}--/, /^\s*#{mark}\+\+/
+            text.strip!
+            text = nil
+          when /^\s*#{mark}/
+            text << "\n" unless text[-1, 1] == "\n"
+            text << line.gsub(/^\s*#{mark}\s*/, "")
+          else
+            text.strip!
+            text = nil
+          end
+        elsif !/^\s*#{mark}/.match?(line)
+          capt << line if capt && capt.size < context
+        end
+      end
+      records
     end
 
     # Is this line a note?
@@ -146,36 +121,33 @@ module DNote
     def match_special(line, lineno, file)
       rec = nil
       labels.each do |label|
-        if md = match_special_regex(label, file).match(line)
+        if (md = match_special_regex(label, file).match(line))
           text = md[1]
-          #rec = {'label'=>label,'file'=>file,'line'=>lineno,'note'=>text}
           rec = Note.new(self, file, label, lineno, text, remark(file))
         end
       end
       rec
     end
 
-    #--
-    # TODO: ruby-1.9.1-p378 reports: `match': invalid byte sequence in UTF-8 
-    #++
     def match_special_regex(label, file)
       mark = remark(file)
+      label = Regexp.escape(label)
       if colon
-        /#{mark}\s*#{Regexp.escape(label)}[:]\s+(.*?)$/
+        /#{mark}\s*#{label}:\s+(.*?)$/
       else
-        /#{mark}\s*#{Regexp.escape(label)}[:]?\s+(.*?)$/
+        /#{mark}\s*#{label}:?\s+(.*?)$/
       end
     end
 
     # Match notes that are labeled with a colon.
     def match_general(line, lineno, file)
       rec = nil
-      if md = match_general_regex(file).match(line)
-        label, text = md[1], md[2]
-        #rec = {'label'=>label,'file'=>file,'line'=>lineno,'note'=>text}
+      if (md = match_general_regex(file).match(line))
+        label = md[1]
+        text = md[2]
         rec = Note.new(self, file, label, lineno, text, remark(file))
       end
-      return rec
+      rec
     end
 
     # Keep in mind that general non-colon matches have a higher potential
@@ -183,84 +155,18 @@ module DNote
     def match_general_regex(file)
       mark = remark(file)
       if colon
-        /#{mark}\s*([A-Z]+)[:]\s+(.*?)$/
-      else 
+        /#{mark}\s*([A-Z]+):\s+(.*?)$/
+      else
         /#{mark}\s*([A-Z]+)\s+(.*?)$/
       end
     end
 
-    # Organize notes into a hash with labels for keys.
-    def by_label
-      @by_label ||= (
-        list = {}
-        notes.each do |note|
-          list[note.label] ||= []
-          list[note.label] << note
-          list[note.label].sort #!{ |a,b| a.line <=> b.line }
-        end
-        list
-      )
-    end
-
-    # Organize notes into a hash with filename for keys.
-    def by_file
-      @by_file ||= (
-        list = {}
-        notes.each do |note|
-          list[note.file] ||= []
-          list[note.file] << note
-          list[note.file].sort! #!{ |a,b| a.line <=> b.line }
-        end
-        list
-      )
-    end
-
-    # Organize notes into a hash with labels for keys, followed
-    # by a hash with filename for keys.
-    def by_label_file
-      @by_label ||= (
-        list = {}
-        notes.each do |note|
-          list[note.label] ||= {}
-          list[note.label][note.file] ||= []
-          list[note.label][note.file] << note
-          list[note.label][note.file].sort! #{ |a,b| a.line <=> b.line }
-        end
-        list
-      )
-    end
-
-    # Organize notes into a hash with filenames for keys, followed
-    # by a hash with labels for keys.
-    def by_file_label
-      @by_file ||= (
-        list = {}
-        notes.each do |note|
-          list[note.file] ||= {}
-          list[note.file][note.label] ||= []
-          list[note.file][note.label] << note
-          list[note.file][note.label].sort! #{ |a,b| a.line <=> b.line }
-        end
-        list
-      )
-    end
-
-    # Convert to an array of hashes.
-    def to_a
-      notes.map{ |n| n.to_h }
-    end
-
-    # Same as #by_label.
-    def to_h
-      by_label
-    end
-
-    #
     def remark(file)
-      @remark[File.extname(file)] ||= (
-        mark = guess_marker(file)
-        Regexp.escape(mark)
-      )
+      @remark[File.extname(file)] ||=
+        begin
+          mark = guess_marker(file)
+          Regexp.escape(mark)
+        end
     end
 
     # Guess marker based on file extension. Fallsback to '#'
@@ -269,52 +175,19 @@ module DNote
     # TODO: Continue to add comment types.
     def guess_marker(file)
       return @marker if @marker # forced marker
+
       case File.extname(file)
-      when '.js', '.c', 'cpp', '.css'
-        '//'
-      when '.bas'
+      when ".js", ".c", "cpp", ".css"
+        "//"
+      when ".bas"
         "'"
-      when '.sql', '.ada'
-        '--'
-      when '.asm'
-        ';'
+      when ".sql", ".ada"
+        "--"
+      when ".asm"
+        ";"
       else
-        '#'        
+        "#"
       end
     end
-
-    # Convert to array of hashes then to YAML.
-    #def to_yaml
-    #  require 'yaml'
-    #  to_a.to_yaml
-    #end
-
-    # Convert to array of hashes then to JSON.
-    #def to_json
-    #  begin
-    #    require 'json'
-    #  rescue LoadError
-    #    require 'json_pure'
-    #  end
-    #  to_a.to_json
-    #end
-
-    # Convert to array of hashes then to a SOAP XML envelope.
-    #def to_soap
-    #  require 'soap/marshal'
-    #  SOAP::Marshal.marshal(to_a)
-    #end
-
-    # XOXO microformat.
-    #--
-    # TODO: Would to_xoxo be better organized by label and or file?
-    #++
-    #def to_xoxo
-    #  require 'xoxo'
-    #  to_a.to_xoxo
-    #end
-
   end
-
 end
-

data/lib/dnote/notes_collection.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DNote
+  # = Notes Collection
+  #
+  # This class contains a collection of Note objects and can group them in
+  # several ways.
+  #
+  class NotesCollection
+    include Enumerable
+
+    def initialize(notes)
+      @notes = notes
+    end
+
+    # Array of notes.
+    attr_reader :notes
+
+    # Notes counts by label.
+    def counts
+      @counts ||=
+        begin
+          h = {}
+          by_label.each do |label, notes|
+            h[label] = notes.size
+          end
+          h
+        end
+    end
+
+    # Iterate through notes.
+    def each(&block)
+      notes.each(&block)
+    end
+
+    # No notes?
+    def empty?
+      notes.empty?
+    end
+
+    # Organize notes into a hash with labels for keys.
+    def by_label
+      @by_label ||= notes.group_by(&:label)
+    end
+
+    # Organize notes into a hash with filename for keys.
+    def by_file
+      @by_file ||= notes.group_by(&:file)
+    end
+
+    # Organize notes into a hash with labels for keys, followed
+    # by a hash with filename for keys.
+    def by_label_file
+      @by_label_file ||= by_label.transform_values { |notes| notes.group_by(&:file) }
+    end
+
+    # Organize notes into a hash with filenames for keys, followed
+    # by a hash with labels for keys.
+    def by_file_label
+      @by_file_label ||= by_file.transform_values { |notes| notes.group_by(&:label) }
+    end
+
+    # Convert to an array of hashes.
+    def to_a
+      notes.map(&:to_h)
+    end
+
+    # Same as #by_label.
+    def to_h
+      by_label
+    end
+  end
+end

data/lib/dnote/options.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "dnote/core_ext"
+require "dnote/notes"
+require "dnote/format"
+require "optparse"
+
+module DNote
+  # Option parser
+  class Options
+    def self.parse(*argv)
+      new(argv).parse
+    end
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def parse
+      session = Session.new
+
+      opts = OptionParser.new do |opt|
+        opt.banner = "DNote v#{DNote::VERSION}"
+
+        opt.separator(" ")
+        opt.separator("USAGE:\n  dnote [OPTIONS] path1 [path2 ...]")
+
+        add_output_format_options(session, opt)
+        add_other_options(session, opt)
+        add_command_options(session, opt)
+      end
+
+      opts.parse!(@argv)
+      session.paths.replace(@argv)
+      session
+    end
+
+    def add_command_options(session, opt)
+      opt.separator(" ")
+      opt.separator("COMMAND OPTIONS:")
+
+      opt.on_tail("--templates", "-T", "list available format templates") do
+        session.list_templates
+        exit
+      end
+
+      opt.on_tail("--help", "-h", "show this help information") do
+        puts opt
+        exit
+      end
+    end
+
+    def add_output_format_options(session, opt)
+      opt.separator(" ")
+      opt.separator("OUTPUT FORMAT: (choose one)")
+
+      opt.on("--format", "-f NAME", "select a format [text]") do |format|
+        session.format = format
+      end
+
+      opt.on("--custom", "-C FILE", "use a custom ERB template") do |file|
+        session.format = "custom"
+        session.template = file
+      end
+
+      opt.on("--file", "shortcut for text/file format") do
+        session.format = "text/file"
+      end
+
+      opt.on("--list", "shortcut for text/list format") do
+        session.format = "text/list"
+      end
+    end
+
+    def add_other_options(session, opt)
+      opt.separator(" ")
+      opt.separator("OTHER OPTIONS:")
+
+      opt.on("--label", "-l LABEL", "labels to collect") do |lbl|
+        session.labels.concat(lbl.split(":"))
+      end
+
+      opt.on(:colon, "--[no-]colon", "match labels with/without colon suffix") do |val|
+        session.colon = val
+      end
+
+      opt.on("--marker", "-m MARK", "alternative remark marker") do |mark|
+        session.marker = mark
+      end
+
+      opt.on("--url", "-u TEMPLATE", "url template for line entries (for HTML)") do |url|
+        session.url = url
+      end
+
+      opt.on("--context", "-c INTEGER", "number of lines of context to display") do |int|
+        session.context = int.to_i
+      end
+
+      opt.on("--exclude", "-x PATH", "exclude file or directory") do |path|
+        session.exclude << path
+      end
+
+      opt.on("--ignore", "-i NAME", "ignore file based on any part of pathname") do |name|
+        session.ignore << name
+      end
+
+      opt.on("--title", "-t TITLE", "title to use in header") do |title|
+        session.title = title
+      end
+
+      opt.on("--output", "-o PATH", "save to file or directory") do |path|
+        session.output = path
+      end
+
+      opt.on("--dryrun", "-n", "do not actually write to disk") do
+        session.dryrun = true
+      end
+
+      opt.on("--debug", "debug mode") do
+        $DEBUG = true
+        $VERBOSE = true
+      end
+    end
+  end
+end