bones 2.5.1 → 3.0.0

data/bin/bones

@@ -1,7 +1,14 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(
-    File.join(File.dirname(__FILE__), '..', 'lib', 'bones'))
-Bones::App.run ARGV
+root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require File.join(root, %w[lib bones])
+rescue LoadError
+  require 'bones'
+end
+
+Bones::App.initialize_plugins
+Bones::App.run
 
 # EOF

data/{spec/data/data → default}/.bnsignore

@@ -4,7 +4,9 @@
 # A .gitignore file can be used instead by setting it as the ignore
 # file in your Rakefile:
 #
-#   PROJ.ignore_file = '.gitignore'
+#   Bones {
+#     ignore_file  '.gitignore'
+#   }
 #
 # For a project with a C extension, the following would be a good set of
 # exclude patterns (uncomment them if you want to use them):

data/default/Rakefile.bns

@@ -0,0 +1,21 @@
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+ensure_in_path 'lib'
+require '<%= name %>'
+
+task :default => 'test:run'
+
+Bones {
+  name  '<%= name %>'
+  authors  'FIXME (who is writing this software)'
+  email  'FIXME (your e-mail)'
+  url  'FIXME (project homepage)'
+  version  <%= classname %>::VERSION
+}
+
+# EOF

data/lib/bones.rb

@@ -1,68 +1,110 @@
 
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'fileutils'
+require 'find'
 require 'rbconfig'
+require 'little-plugger'
+require 'loquacious'
+require 'git'
 
 module Bones
+  extend LittlePlugger
 
   # :stopdoc:
-  VERSION = '2.5.1'
+  VERSION = '3.0.0'
   PATH = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  LIBPATH = File.expand_path(File.join(PATH, 'lib'))
   HOME = File.expand_path(ENV['HOME'] || ENV['USERPROFILE'])
-  DEV_NULL = File.exist?('/dev/null') ? '/dev/null' : 'NUL:'
 
   # Ruby Interpreter location - taken from Rake source code
   RUBY = File.join(Config::CONFIG['bindir'],
                    Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
+
+  module Plugins; end
   # :startdoc:
 
   # Returns the path for Mr Bones. If any arguments are given,
-  # they will be joined to the end of the path using
-  # <tt>File.join</tt>.
+  # they will be joined to the end of the path using <tt>File.join</tt>.
   #
   def self.path( *args )
     args.empty? ? PATH : File.join(PATH, args.flatten)
   end
 
+  # Returns the lib path for Mr Bones. If any arguments are given,
+  # they will be joined to the end of the path using <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : File.join(LIBPATH, args.flatten)
+  end
+
   # call-seq:
-  #    Bones.require_all_libs_relative_to( filename, directory = nil )
+  #    Bones.config
+  #    Bones.config { block }
   #
-  # Utility method used to rquire all files ending in .rb that lie in the
-  # directory below this file that has the same name as the filename passed
-  # in. Optionally, a specific _directory_ name can be passed in such that
-  # the _filename_ does not have to be equivalent to the directory.
+  # Returns the configuration object for setting up Mr Bones options.
   #
-  def self.require_all_libs_relative_to( fname, dir = nil )
-    dir ||= File.basename(fname, '.*')
-    search_me = File.expand_path(
-        File.join(File.dirname(fname), dir, '*.rb'))
+  def self.config( &block )
+    Loquacious.configuration_for('Bones', &block)
+  end
 
-    Dir.glob(search_me).sort.each {|rb| require rb}
+  # call-seq:
+  #    Bones.help
+  #
+  # Returns a help object that can be used to show the current Mr Bones
+  # configuration and descriptions for the various configuration attributes.
+  #
+  def self.help
+    Loquacious.help_for('Bones', :colorize => config.colorize, :nesting_nodes => false)
   end
+end  # module Bones
+
+begin
+  $LOAD_PATH.unshift Bones.libpath
+  %w[colors helpers gem_package_task annotation_extractor smtp_tls app app/command app/file_manager].
+  each { |fn| require File.join('bones', fn) }
 
+  Bones.config {}
+  Loquacious.remove :gem, :file, :test
+ensure
+  $LOAD_PATH.shift
+end
+
+module Kernel
   # call-seq:
-  #    Bones.setup
+  #    Bones { block }
   #
+  # Configure Mr Bones using the given _block_ of code. If a block is not
+  # given, the Bones module is returned.
   #
-  def self.setup
-    local_setup = File.join(Dir.pwd, %w[tasks setup.rb])
+  def Bones( &block )
 
-    if test(?e, local_setup)
-      load local_setup
-      return
-    end
+    # we absolutely have to have the bones plugin
+    plugin_names = ::Bones.plugin_names
+    ::Bones.plugin :bones_plugin unless plugin_names.empty? or plugin_names.include? :bones_plugin
 
-    bones_setup = ::Bones.path %w[lib bones tasks setup.rb]
-    load bones_setup
+    plugins = ::Bones.initialize_plugins.values
+    return ::Bones unless block
 
-    rakefiles = Dir.glob(File.join(Dir.pwd, %w[tasks *.rake])).sort
-    rakefiles.each {|fn| Rake.application.add_import(fn)}
-  end
+    config = ::Bones.config
+    extend_method = Object.new.method(:extend).unbind.bind(config)
+    instance_eval_method = Object.new.method(:instance_eval).unbind.bind(config)
 
-  # TODO: fix file lists for Test::Unit and RSpec
-  #       these guys are just grabbing whatever is there and not pulling
-  #       the filenames from the manifest
+    plugins.each { |plugin|
+      ps = plugin.const_get :Syntax rescue next
+      extend_method.call ps
+    }
+    instance_eval_method.call(&block)
 
-end  # module Bones
+    # config.exclude << "^#{Regexp.escape(config.rcov.dir)}/"
 
-Bones.require_all_libs_relative_to(__FILE__)
+    plugins.each { |plugin| plugin.post_load if plugin.respond_to? :post_load }
+    plugins.each { |plugin| plugin.define_tasks if plugin.respond_to? :define_tasks }
+
+    rakefiles = Dir.glob(File.join(Dir.pwd, %w[tasks *.rake])).sort
+    rakefiles.each {|fn| Rake.application.add_import(fn)}
+  end
+end
 
 # EOF

data/lib/bones/annotation_extractor.rb

@@ -1,19 +1,10 @@
 
-begin
-  require 'facets/ansicode'
-  HAVE_COLOR = true
-rescue LoadError
-  HAVE_COLOR = false
-end
-
-module Bones
-
 # A helper class used to find and display any annotations in a collection of
 # project files.
 #
-class AnnotationExtractor
+class Bones::AnnotationExtractor
 
-  class Annotation < Struct.new(:line, :tag, :text)
+  Annotation = Struct.new(:line, :tag, :text) {
     # Returns a string representation of the annotation. If the
     # <tt>:tag</tt> parameter is given as +true+, then the annotation tag
     # will be included in the string.
@@ -23,25 +14,25 @@ class AnnotationExtractor
       s << "[#{tag}] " if opts[:tag]
       s << text
     end
-  end
+  }
 
-  # Enumerate all the annoations for the given _project_ and _tag_. This
+  # Enumerate all the annoations for the given _config_ and _tag_. This
   # will search for all athe annotations and display them on standard
   # output.
   #
-  def self.enumerate( project, tag, id = nil, opts = {} )
-    extractor = new(project, tag, id)
+  def self.enumerate( config, tag, id = nil, opts = {} )
+    extractor = new(config, tag, id)
     extractor.display(extractor.find, opts)
   end
 
-  attr_reader :tag, :project, :id
+  attr_reader :tag, :config, :id
 
-  # Creates a new annotation extractor configured to use the _project_ open
+  # Creates a new annotation extractor configured to use the _config_ open
   # strcut and to search for the given _tag_ (which can be more than one tag
   # via a regular expression 'or' operation -- i.e. THIS|THAT|OTHER)
   #
-  def initialize( project, tag, id) 
-    @project = project
+  def initialize( config, tag, id) 
+    @config = config
     @tag = tag
     @id = @id_rgxp = nil
 
@@ -58,11 +49,11 @@ class AnnotationExtractor
     results = {}
     rgxp = %r/(#{tag}):?\s*(.*?)(?:\s*(?:-?%>|\*+\/))?$/o
 
-    extensions = project.notes.extensions.dup
-    exclude = if project.notes.exclude.empty? then nil
-              else Regexp.new(project.notes.exclude.join('|')) end
+    extensions = config.notes.extensions.dup
+    exclude = if config.notes.exclude.empty? then nil
+              else Regexp.new(config.notes.exclude.join('|')) end
 
-    project.gem.files.each do |fn|
+    config.gem.files.each do |fn|
       next if exclude && exclude =~ fn
       next unless extensions.include? File.extname(fn)
       results.update(extract_annotations_from(fn, rgxp))
@@ -83,7 +74,7 @@ class AnnotationExtractor
 
       text = m[2]
       if text =~ @id_rgxp
-        text.gsub!(@id_rgxp) {|str| ANSICode.green(str)} if HAVE_COLOR
+        text.gsub!(@id_rgxp) {|str| ::Bones::Colors.green(str)} if config.colorize
         list << Annotation.new(lineno, m[1], text)
       end
       list
@@ -105,7 +96,6 @@ class AnnotationExtractor
     end
   end
 
-end  # class AnnotationExtractor
-end  # module Bones
+end  # class Bones::AnnotationExtractor
 
 # EOF

data/lib/bones/app.rb

@@ -1,58 +1,80 @@
 
-require 'fileutils'
-require 'optparse'
-require 'erb'
+require 'net/http'
+require 'uri'
 
-module Bones
-class App
+module Bones::App
+  extend LittlePlugger(:path => 'bones/app', :module => Bones::App)
+  disregard_plugins :error, :main, :command, :file_manager
 
-  # Create a new instance of App, and run the +bones+ application given
-  # the command line _args_.
-  #
-  def self.run( args )
-    self.new.run args
-  end
+  Error = Class.new(StandardError)
 
-  # Create a new main instance using _io_ for standard output and _err_ for
-  # error messages.
+  # Create a new instance of Main, and run the +bones+ application given
+  # the command line _args_.
   #
-  def initialize( out = STDOUT, err = STDERR )
-    @out = out
-    @err = err
+  def self.run( args = nil )
+    args ||= ARGV.dup.map! { |v| v.dup }
+    ::Bones::App::Main.new.run args
   end
 
-  # Parse the desired user command and run that command object.
-  #
-  def run( args )
-    cmd_str = args.shift
-    cmd = case cmd_str
-      when 'create';    CreateCommand.new(@out, @err)
-      when 'update';    UpdateCommand.new(@out, @err)
-      when 'freeze';    FreezeCommand.new(@out, @err)
-      when 'unfreeze';  UnfreezeCommand.new(@out, @err)
-      when 'info';      InfoCommand.new(@out, @err)
-      when nil, '-h', '--help'
-        help
-      when '-v', '--version'
-        @out.puts "Mr Bones #{::Bones::VERSION}"
-        nil
-      else
-        raise "Unknown command #{cmd_str.inspect}"
+  class Main
+    attr_reader :stdout
+    attr_reader :stderr
+
+    # Create a new Main application instance. Options can be passed to
+    # configuret he stdout and stderr IO streams (very useful for testing).
+    #
+    def initialize( opts = {} )
+      opts[:stdout] ||= $stdout
+      opts[:stderr] ||= $stderr
+
+      @opts = opts
+      @stdout = opts[:stdout]
+      @stderr = opts[:stderr]
+    end
+
+    # Parse the desired user command and run that command object.
+    #
+    def run( args )
+      commands = []
+      @plugins = ::Bones::App.plugins
+      @plugins.each { |k,v| commands << k.to_s if v < ::Bones::App::Command }
+
+      cmd_str = args.shift
+      cmd = case cmd_str
+        when *commands
+          key = cmd_str.to_sym
+          @plugins[key].new @opts
+        when nil, '-h', '--help'
+          help
+        when '-v', '--version'
+          stdout.puts "Mr Bones v#{::Bones::VERSION}"
+        else
+          raise Error, "Unknown command #{cmd_str.inspect}"
+        end
+
+      if cmd
+        cmd.parse args
+        cmd.run
       end
 
-    cmd.run args if cmd
-
-  rescue StandardError => err
-    @err.puts "ERROR:  While executing bones ... (#{err.class})"
-    @err.puts "    #{err.to_s}"
-    exit 1
-  end
-
-  # Show the toplevel Mr Bones help message.
-  #
-  def help
-    @out.puts <<-MSG
-
+    rescue Bones::App::Error => err
+      stderr.puts "ERROR:  While executing bones ..."
+      stderr.puts "    #{err.message}"
+      exit 1
+    rescue StandardError => err
+      stderr.puts "ERROR:  While executing bones ... (#{err.class})"
+      stderr.puts "    #{err.to_s}"
+      exit 1
+    end
+
+    # Show the toplevel Mr Bones help message.
+    #
+    def help
+      msg = <<-MSG
+NAME
+  bones v#{::Bones::VERSION}
+
+DESCRIPTION
   Mr Bones is a handy tool that builds a skeleton for your new Ruby
   projects. The skeleton contains some starter code and a collection of
   rake tasks to ease the management and deployment of your source code.
@@ -68,25 +90,32 @@ class App
     bones create -s bort new_rails_project
 
   Commands:
-    bones create          create a new project from a skeleton
-    bones update          copy Mr Bones tasks to a project
-    bones freeze          create a new skeleton in ~/.mrbones/
-    bones unfreeze        remove a skeleton from ~/.mrbones/
-    bones info            show information about available skeletons
+      MSG
+
+     fmt = lambda { |cmd|
+             if @plugins[cmd] < ::Bones::App::Command
+               msg << "    bones %-15s %s\n" % [cmd, @plugins[cmd].summary]
+             end
+           }
+
+     ary = [:create, :freeze, :unfreeze, :info]
+     ary.each(&fmt)
+     (@plugins.keys - ary).each(&fmt)
+
+      msg.concat <<-MSG
 
   Further Help:
     Each command has a '--help' option that will provide detailed
     information for that command.
 
-    http://codeforpeople.rubyforge.org/bones/
+    http://github.com/TwP/bones
 
-    MSG
-    nil
-  end
+      MSG
 
-end  # class App
-end  # module Bones
+    stdout.puts msg
+    end
 
-Bones.require_all_libs_relative_to(__FILE__)
+  end  # class Main
+end  # module Bones::App
 
 # EOF