quarry 0.3.0 → 0.4.0

data/work/sandbox/build/make.rb

@@ -0,0 +1,118 @@
+
+# The Make tool routes to extension Makefile(s).
+# At this point it's designed to support extconf.rb design.
+#
+# TODO Perhaps make a true compiler class in the future.
+
+require 'reap/tool'
+
+module Reap
+module Tools
+
+  class Make < Tool
+
+    attr_accessor :extensions
+
+    def extensions
+      @extensions ||= 'ext/**/extconf.rb'
+    end
+
+    # Check to see if this project has extensions that need to be compiled.
+
+    def compiles?
+      return false if extension_directories.empty?
+    end
+
+    # Compile extensions.
+
+    def compile
+      extension_directories.each do |directory|
+        cd(directory) do
+          sh "ruby extconf.rb"  # prepare
+          sh "make"
+        end
+      end
+    end
+
+    alias_method :call, :compile
+
+    # Run make config.
+
+    def config
+      extension_directories.each do |directory|
+        cd(directory) do
+          sh "make config"
+        end
+      end
+    end
+
+    # Remove enouhg compile products for a clean compile.
+
+    def clean
+      extension_directories.each do |directory|
+        cd(directory) do
+          sh "make clean"
+        end
+      end
+    end
+
+    # Remove all compile products.
+
+    def distclean
+      extension_directories.each do |directory|
+        cd(directory) do
+          sh "make distclean"
+        end
+      end
+    end
+
+    # Create Makefiles.
+
+    def extconf
+      extension_directories.each do |directory|
+        cd(directory) do
+          sh "ruby extconf.rb"
+        end
+      end
+    end
+
+    # Return list of extconf.rb scripts.
+
+    def extension_scripts
+      [extensions].flatten.collect do |ext|
+        Dir.glob(ext)
+      end.flatten
+    end
+
+    # Return list of directory locations of extconf.rb scripts.
+
+    def extension_directories
+      glob(extension_scripts).map do |ext|
+        File.dirname(ext)
+      end
+    end
+
+    # Eric Hodel said NOT to copy the compiled libs.
+    #
+    #task :copy_files do
+    #  cp "ext/**/*.#{dlext}", "lib/**/#{arch}/"
+    #end
+    #
+    #def dlext
+    #  Config::CONFIG['DLEXT']
+    #end
+    #
+    #def arch
+    #  Config::CONFIG['arch']
+    #end
+
+    # Cross-compile for Windows. (TODO)
+
+    #def make_mingw
+    #  abort "NOT YET IMPLEMENTED"
+    #end
+
+  end
+
+end
+end

data/work/sandbox/build/manpage.rb

@@ -0,0 +1,201 @@
+require 'yaml'
+require 'quarry/build'
+
+module Quarry
+
+  # This takes a manpage with a YAML based header comment
+  # and appends man page format.
+
+  class Manpage < Build
+
+    def self.generate(file, options={})
+       new.generate(file, options)
+    end
+
+    TOP_ORDER = %w{ NAME SYNOPSIS DESCRIPTION OPTIONS }
+    BOT_ORDER = %w{ AUTHOR }
+
+    def generate(file, options={})
+      text = read(file)
+      data = load(text)
+      manp = parse(data)
+      if options[:dryrun]
+        puts manp
+      else
+        save(file, text, manp)
+      end
+    end
+
+    def read(file)
+      text = File.read(file)
+      re = Regexp.escape('.\"')
+      lines = text.split(/\n/).select do |l|
+        /^#{re}/ =~ l
+      end
+      text = lines.join("\n")
+    end
+
+    #
+    def load(text)
+      str = text.split(/\n/).collect do |l|
+        l.sub('.\"', '')
+      end
+      YAML.load(str.join("\n"))
+    end
+
+    def save(file, text, manp)
+      File.open(file, 'w') do |f|
+        f << text << "\n"
+        f << manp
+      end
+    end
+
+    def parse(data)
+      title = data.delete('TITLE')
+      secno = data.delete('SECTION')
+      verno = data.delete('VERSION')
+      name  = data.fetch('NAME')
+
+      raise "Missing required field TITLE or NAME" unless title && name
+
+      top = []
+      bot = []
+      mid = []
+
+      # do section top order
+      TOP_ORDER.each do |section|
+        if content = data.delete(section)
+          top << process_section(section, content)
+        end
+      end
+
+      BOT_ORDER.each do |section|
+        if content = data.delete(section)
+          bot << process_section(section, content)
+        end
+      end
+
+      # do remaining sections.
+      data.each do |section, content|
+        mid << process_section(section, content)
+      end
+
+      man = []
+      man << man_topsection(title, secno, verno)
+      man.concat top
+      man.concat mid
+      man.concat bot
+      man.join("\n")
+    end
+
+    def process_section(section, content)
+      meth = "man_" + section.downcase.gsub(' ','_')
+      if respond_to?(meth)
+        send(meth, content)
+      else
+        general_section(section.upcase, content)
+      end
+    end
+
+    def man_topsection(title, secno, verno)
+      secno ||= 1
+      verno ||= "1.0"
+      date = Time.now.strftime("%d %B %Y")
+      %{.TH man #{secno} "#{date}" "#{verno}" "#{title}"}
+    end
+
+    def man_name(content)
+      str = ''
+      str << ".SH NAME\n"
+      str << format(content)
+    end
+
+    def man_synopsis(content)
+      str = ''
+      str << ".SH SYNOPSIS\n"
+      str << ".B " + format(content)
+    end
+
+    def man_examples(content)
+      name = "EXAMPLES"
+      general_section(name, content)
+    end
+
+    def man_description(content)
+      name = "DESCRIPTION"
+      general_section(name, content)
+    end
+
+    def man_options(content)
+      name = "OPTIONS"
+      general_section(name, content)
+    end
+
+    def man_files(content)
+      name = "FILES"
+      general_section(name, content)
+    end
+
+    def man_see_also(content)
+      str = ''
+      str << ".SH SEE ALSO\n"
+      see = content.split(/[,]\s*/)
+      see.each do |s|
+        str << ".BR #{s},\n"
+      end
+      str.strip
+    end
+
+    def man_bugs(content)
+      name = "BUGS"
+      general_section(name, content)
+    end
+
+    def man_hints(content)
+      name = "HINTS"
+      general_section(name, content)
+    end
+
+    def man_environment(content)
+      name = "ENVIRONMENT"
+      general_section(name, content)
+    end
+
+    def man_diagnostics(content)
+      name = "DIAGNOSTICS"
+      general_section(name, content)
+    end
+
+    # ?????
+    def man_list(content)
+      name = "LIST"
+      general_section(name, content)
+    end
+
+    def man_author(content)
+      name = "AUTHOR"
+      general_section(name, content)
+    end
+
+    def man_history(content)
+      name = "HISTORY"
+      general_section(name, content)
+    end
+
+    #
+
+    def general_section(name, content)
+      str = ''
+      str << ".SH #{name.upcase}\n"
+      str << format(content)
+    end
+
+    def format(content)
+      content = content.strip
+      content = content.gsub(' -', ' \-')
+      content #<< "\n"
+    end
+
+  end
+
+end

data/work/sandbox/build/notes.rb

@@ -0,0 +1,214 @@
+require 'quarry/build'
+
+module Quarry
+
+  class Notes < Build
+
+    attr_accessor :files
+    attr_accessor :labels
+    attr_accessor :format
+    attr_accessor :output
+
+    # TODO Add ability to read header notes.
+    # FIXME Should each label of note be written to it's own file?
+
+    DEFAULT_NOTE_FILES  = ['lib/**/*', 'ext/**/*']
+    DEFAULT_NOTE_LABELS = ['TODO', 'FIXME']
+    DEFAULT_NOTE_FORMAT = 'rdoc'
+    DEFAULT_NOTE_OUTPUT = 'doc/note'
+
+    #
+
+    def files
+      @files ||= DEFAULT_NOTE_FILES
+    end
+
+    #
+
+    def labels
+      @labels ||= DEFAULT_NOTE_LABELS
+    end
+
+    #
+
+    def format
+      @format ||= DEFAULT_NOTE_FORMAT
+    end
+
+    #
+
+    def output
+      @output ||= DEFAULT_NOTE_OUTPUT
+    end
+
+    # Scan for notes.
+    #
+    # This task scans source code for developer notes and writes to
+    # well organized files.
+    #
+    # Notes tool can lookup and list TODO, FIXME and
+    # other types of labeled comments from source code.
+
+    def notes(config={})
+      files  = config['files']  || files()
+      labels = config['labels'] || labels()
+      format = config['format'] || format()
+      outout = config['output'] || output()
+
+      files  ||= DEFAULT_NOTE_FILES
+      labels ||= DEFAULT_NOTE_LABELS
+      format ||= DEFAULT_NOTE_FORMAT
+      output ||= DEFAULT_NOTE_OUTPUT
+
+      labels = labels.split(',') if String === labels
+      labels = [labels].flatten.compact
+
+      output.chomp!('/')
+
+      records, counts = extract_notes( labels, files )
+      notes = format_notes( labels, records, format )
+
+      if records.empty?
+        puts "No #{labels.join('/')} notes."
+      end
+
+      save_notes(output, notes, labels)
+      puts counts.collect{|l,n| "#{n} #{l}s"}.join(', ')
+      puts "Notes saved in #{output} folder."
+    end
+
+    private
+
+    # Gather notes.
+
+    def extract_notes( labels, files=nil )
+      files = files || info.scripts || info.note_files || DEFAULT_NOTE_FILES
+      files = Dir.multiglob_with_default(DEFAULT_NOTE_FILES, *files)
+
+      counts = Hash.new(0)
+      records = []
+
+      files.each do |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
+      return records, counts
+    end
+
+    # Format notes.
+
+    def format_notes( labels, records, format=nil )
+      #return "No #{labels.join('/')} notes." if records.empty?
+      #return {} if records.empty?
+      notes = {}
+      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
+        notes[label] = out
+      end
+      return notes
+    end
+
+    # Save notes.
+
+    def save_notes( dir, notes, labels )
+      # Remove empty note files.
+      (labels - notes.keys).each do |label|
+        file = File.join(dir,label)
+        rm(file) if File.file?(file)
+      end
+      # Create note files.
+      notes.each do |label, note|
+        file = File.join(dir,label)
+        file = apply_naming_policy(file, 'txt')
+        if dryrun?
+          puts "write #{file}"
+        else
+          File.open(file,'w') do |f| f << note end
+        end
+      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