TwP-bones 2.3.0

data/data/Rakefile.bns

@@ -0,0 +1,30 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require '<%= name %>'
+
+task :default => 'spec:run'
+
+PROJ.name = '<%= name %>'
+PROJ.authors = 'FIXME (who is writing this software)'
+PROJ.email = 'FIXME (your e-mail)'
+PROJ.url = 'FIXME (project homepage)'
+PROJ.version = <%= classname %>::VERSION
+PROJ.rubyforge.name = '<%= name %>'
+
+PROJ.spec.opts << '--color'
+
+# EOF

data/data/bin/NAME.bns

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib <%= name %>]))
+
+# Put your code here
+
+# EOF

data/data/lib/NAME.rb.bns

@@ -0,0 +1,49 @@
+
+module <%= classname %>
+
+  # :stopdoc:
+  VERSION = '1.0.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # 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
+
+  # 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.
+  #
+  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'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module <%= classname %>
+
+<%= classname %>.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/data/spec/NAME_spec.rb.bns

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe <%= classname %> do
+end
+
+# EOF

data/data/spec/spec_helper.rb.bns

@@ -0,0 +1,16 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib <%= name %>]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

data/lib/bones/annotation_extractor.rb

@@ -0,0 +1,111 @@
+
+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 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.
+    #
+    def to_s( opts = {} )
+      s = "[%3d] " % line
+      s << "[#{tag}] " if opts[:tag]
+      s << text
+    end
+  end
+
+  # Enumerate all the annoations for the given _project_ 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)
+    extractor.display(extractor.find, opts)
+  end
+
+  attr_reader :tag, :project, :id
+
+  # Creates a new annotation extractor configured to use the _project_ 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
+    @tag = tag
+    @id = @id_rgxp = nil
+
+    unless id.nil? or id.empty?
+      @id = id
+      @id_rgxp = Regexp.new(Regexp.escape(id), Regexp::IGNORECASE)
+    end
+  end
+
+  # Iterate over all the files in the project and extract annotations from
+  # the those files. Returns the results as a hash for display.
+  #
+  def find
+    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
+
+    project.gem.files.each do |fn|
+      next if exclude && exclude =~ fn
+      next unless extensions.include? File.extname(fn)
+      results.update(extract_annotations_from(fn, rgxp))
+    end
+
+    results
+  end
+
+  # Extract any annotations from the given _file_ using the regular
+  # expression _pattern_ provided.
+  #
+  def extract_annotations_from( file, pattern )
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless m = pattern.match(line)
+      next list << Annotation.new(lineno, m[1], m[2]) unless id
+
+      text = m[2]
+      if text =~ @id_rgxp
+        text.gsub!(@id_rgxp) {|str| ANSICode.green(str)} if HAVE_COLOR
+        list << Annotation.new(lineno, m[1], text)
+      end
+      list
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  # Print the results of the annotation extraction to the screen. If the
+  # <tt>:tags</tt> option is set to +true+, then the annotation tag will be
+  # displayed.
+  #
+  def display( results, opts = {} )
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(opts)}"
+      end
+      puts
+    end
+  end
+
+end  # class AnnotationExtractor
+end  # module Bones
+
+# EOF

data/lib/bones/app/command.rb

@@ -0,0 +1,130 @@
+
+module Bones
+class App
+
+class Command
+
+  attr_reader :options
+
+  def initialize( out = STDOUT, err = STDERR )
+    @out = out
+    @err = err
+    @options = {
+      :skeleton_dir => File.join(mrbones_dir, 'data'),
+      :with_tasks => false,
+      :verbose => false,
+      :name => nil,
+      :output_dir => nil
+    }
+    @options[:skeleton_dir] = ::Bones.path('data') unless test(?d, skeleton_dir)
+  end
+
+  def run( args )
+    raise NotImplementedError
+  end
+
+  # The output directory where files will be written.
+  #
+  def output_dir
+    options[:output_dir]
+  end
+
+  # The directory where the project skeleton is located.
+  #
+  def skeleton_dir
+    options[:skeleton_dir]
+  end
+
+  # The project name from the command line.
+  #
+  def name
+    options[:name]
+  end
+
+  # A git or svn repository URL from the command line.
+  #
+  def repository
+    return options[:repository] if options.has_key? :repository
+    return IO.read(skeleton_dir).strip if skeleton_dir and test(?f, skeleton_dir)
+    nil
+  end
+
+  # Returns +true+ if we are going to copy the Mr Bones tasks into the
+  # destination directory. Normally this will return +false+.
+  #
+  def with_tasks?
+    options[:with_tasks]
+  end
+
+  #
+  #
+  def copy_tasks( to )
+    fm = FileManager.new(
+      :source => ::Bones.path(%w[lib bones tasks]),
+      :destination => to,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+    fm.archive_destination
+    fm.copy
+  end
+
+  # Returns +true+ if the user has requested verbose messages.
+  #
+  def verbose?
+    options[:verbose]
+  end
+
+  # Returns the .bones resource directory in the user's home directory.
+  #
+  def mrbones_dir
+    return @mrbones_dir if defined? @mrbones_dir
+
+    path = (::Bones::WIN32 ? ENV['HOMEPATH'].tr("\\", "/") : ENV['HOME'])
+    path = File.join(path, '.mrbones')
+    @mrbones_dir = File.expand_path(path)
+  end
+
+  #
+  #
+  def standard_options
+    {
+      :verbose => ['-v', '--verbose', 'enable verbose output',
+          lambda {
+            options[:verbose] = true
+          }],
+      :directory => ['-d', '--directory DIRECTORY', String,
+          'project directory to create', '(defaults to project_name)',
+          lambda { |value|
+            options[:output_dir] = value
+          }],
+      :skeleton => ['-s', '--skeleton NAME', String,
+          'project skeleton to use',
+          lambda { |value|
+            path = File.join(mrbones_dir, value)
+            if test(?e, path)
+              options[:skeleton_dir] = path 
+            elsif test(?e, value)
+              options[:skeleton_dir] = value
+            else
+              raise ArgumentError, "Unknown skeleton '#{value}'"
+            end
+          }],
+      :with_tasks => ['--with-tasks', 'copy rake tasks to the project folder',
+          lambda {
+            options[:with_tasks] = true
+          }],
+      :repository => ['-r', '--repository URL', String,
+          'svn or git repository path', 
+          lambda { |value|
+            options[:repository] = value
+          }]
+    }
+  end
+
+end  # class Command
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/create_command.rb

@@ -0,0 +1,86 @@
+
+module Bones
+class App
+
+class CreateCommand < Command
+
+  def run( args )
+    parse args
+
+    fm = FileManager.new(
+      :source => repository || skeleton_dir,
+      :destination => output_dir,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+    raise "Output directory already exists #{output_dir.inspect}" if test(?e, fm.destination)
+
+    begin
+      fm.copy
+      copy_tasks(File.join(output_dir, 'tasks')) if with_tasks?
+      fm.finalize name
+
+      pwd = File.expand_path(FileUtils.pwd)
+      msg = "Created '#{name}'"
+      msg << " in directory '#{output_dir}'" if name != output_dir
+      @out.puts msg
+
+      if test(?f, File.join(output_dir, 'Rakefile'))
+        begin
+          FileUtils.cd output_dir
+          @out.puts "Now you need to fix these files"
+          system "rake notes"
+        ensure
+          FileUtils.cd pwd
+        end
+      end
+    rescue Exception => err
+      FileUtils.rm_rf output_dir
+      msg = "Could not create '#{name}'"
+      msg << " in directory '#{output_dir}'" if name != output_dir
+      raise msg
+    end
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones create [options] <project_name>'
+
+    opts.separator ''
+    opts.separator "  Create a new project from a Mr Bones project skeleton. The skeleton can"
+    opts.separator "  be the default project skeleton from the Mr Bones gem or one of the named"
+    opts.separator "  skeletons found in the '~/.mrbones/' folder. A git or svn repository can"
+    opts.separator "  be used as the skeleton if the '--repository' flag is given."
+
+    opts.separator ''
+    opts.on(*std_opts[:directory])
+    opts.on(*std_opts[:skeleton])
+    opts.on(*std_opts[:repository])
+    opts.on(*std_opts[:with_tasks])
+
+    opts.separator ''
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      @out.puts opts
+      exit
+    }
+
+    # parse the command line arguments
+    opts.parse! args
+    options[:name] = args.empty? ? nil : args.join('_')
+
+    if name.nil?
+      @out.puts opts
+      exit 1
+    end
+    options[:output_dir] = name if output_dir.nil?
+  end
+
+end  # class CreateCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/file_manager.rb

@@ -0,0 +1,176 @@
+
+require 'fileutils'
+
+module Bones
+class App
+
+class FileManager
+
+  attr_accessor :source, :destination, :archive, :verbose
+  alias :verbose? :verbose
+
+  #
+  #
+  def initialize( opts = {} )
+    self.source = opts[:source]
+    self.destination = opts[:destination]
+    self.verbose = opts[:verbose]
+
+    @out = opts[:stdout] || $stdout
+    @err = opts[:stderr] || $stderr
+  end
+
+  # Sets the destination where files will be copied to. At the same time an
+  # archive directory is configured. This is simply the destination
+  # directory with a '.archive' extension.
+  #
+  def destination=( str )
+    @destination = str
+    @archive = str + '.archive' if str
+  end
+
+  # If the source is a repository this method returns the type of
+  # repository. This will be :git for Git repositories and :svn for
+  # Subversion repositories. Otherwise, +nil+ is returned.
+  #
+  def repository
+    return :git if source =~ %r/\.git\/?$/i
+    return :svn if source =~ %r/^(svn(\+ssh)?|https?|file):\/\//i
+    nil
+  end
+  alias :repository? :repository
+
+  #
+  #
+  def archive_destination
+    return false unless test(?e, destination)
+
+    @out.puts "archiving #{destination}" if verbose?
+    FileUtils.rm_rf(archive)
+    FileUtils.mv(destination, archive)
+    true
+  end
+
+  #
+  #
+  def copy
+    if repository?
+      _checkout(repository)
+    else
+      _files_to_copy.each {|fn| _cp(fn)}
+    end
+  end
+
+  #
+  #
+  def finalize( name )
+    name = name.to_s
+    return if name.empty?
+
+    self.destination = _rename(destination, name)
+    _erb(name)
+
+    self
+  end
+
+  #
+  #
+  def _checkout( repotype )
+    case repotype
+    when :git
+      system('git-clone', source, destination)
+      FileUtils.rm_rf(File.join(destination, '.git'))
+    when :svn
+      system('svn', 'export', source, destination)
+    else
+      raise "unknown repository type '#{repotype}'"
+    end
+  end
+
+  #
+  #
+  def _rename( filename, name )
+    newname = filename.gsub(%r/NAME/, name)
+
+    if filename != newname
+      raise "cannot rename '#{filename}' to '#{newname}' - file already exists" if test(?e, newname)
+      FileUtils.mv(filename, newname)
+    end
+
+    if test(?d, newname)
+      Dir.glob(File.join(newname, '*')).each {|fn| _rename(fn, name)}
+    end
+    newname
+  end
+
+  #
+  #
+  def _erb( name )
+    binding = _erb_binding(name)
+
+    Dir.glob(File.join(destination, '**', '*')).each do |fn|
+      next unless test(?f, fn) and '.bns' == File.extname(fn)
+
+      txt = ERB.new(File.read(fn), nil, '-').result(binding)
+      File.open(fn.sub(%r/\.bns$/, ''), 'w') {|fd| fd.write(txt)}
+      FileUtils.rm_f(fn)
+    end
+    self
+  end
+
+  #
+  #
+  def _erb_binding( name )
+    obj = Object.new
+    class << obj
+      alias :__binding__ :binding
+      instance_methods.each do |m|
+        undef_method m unless m[%r/^__/]
+      end
+      attr_accessor :name, :classname
+    end
+    obj.name = name
+    obj.classname = name.tr('-','_').split('_').map {|x| x.capitalize}.join
+    obj.__send__(:__binding__)
+  end
+
+  # Returns a list of the files to copy from the source directory to
+  # the destination directory.
+  #
+  def _files_to_copy
+    rgxp = %r/\A#{source}\/?/
+    exclude = %r/tmp$|bak$|~$|CVS|\.svn/
+
+    ary = Dir.glob(File.join(source, '**', '*.*'), File::FNM_DOTMATCH).map do |filename|
+      next if exclude =~ filename
+      next if test(?d, filename)
+      filename.sub rgxp, ''
+    end
+
+    ary.compact!
+    ary.sort!
+    ary
+  end
+
+  # Copy a file from the Bones prototype project location to the user
+  # specified project location. A message will be displayed to the screen
+  # indicating that the file is being created.
+  #
+  def _cp( file )
+    dir = File.dirname(file)
+    dir = (dir == '.' ? destination : File.join(destination, dir))
+    dst = File.join(dir,  File.basename(file))
+    src = File.join(source, file)
+
+    @out.puts(test(?e, dst) ? "updating #{dst}" : "creating #{dst}") if verbose?
+    FileUtils.mkdir_p(dir)
+    FileUtils.cp src, dst
+
+    FileUtils.chmod(File.stat(src).mode, dst)
+  end
+
+end  # class FileManager
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/freeze_command.rb

@@ -0,0 +1,72 @@
+
+module Bones
+class App
+
+class FreezeCommand < Command
+
+  def run( args )
+    parse args
+
+    fm = FileManager.new(
+      :source => repository || ::Bones.path('data'),
+      :destination => output_dir,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+
+    fm.archive_destination
+    return freeze_to_repository if repository
+
+    fm.copy
+    copy_tasks(File.join(output_dir, 'tasks')) if with_tasks?
+
+    @out.puts "Project skeleton #{name.inspect} " <<
+              "has been frozen to Mr Bones #{::Bones::VERSION}"
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones freeze [options] [skeleton_name]'
+
+    opts.separator ''
+    opts.separator '  Freeze the project skeleton to the current Mr Bones project skeleton.'
+    opts.separator '  If a name is not given, then the default name "data" will be used.'
+    opts.separator '  Optionally a git or svn repository can be frozen as the project'
+    opts.separator '  skeleton.'
+
+    opts.separator ''
+    opts.on(*std_opts[:repository])
+    opts.on(*std_opts[:with_tasks])
+
+    opts.separator ''
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      @out.puts opts
+      exit
+    }
+
+    # parse the command line arguments
+    opts.parse! args
+    options[:name] = args.empty? ? 'data' : args.join('_')
+    options[:output_dir] = File.join(mrbones_dir, name)
+  end
+
+  # Freeze the project skeleton to the git or svn repository that the user
+  # passed in on the command line. This essentially creates an alias to the
+  # reposiory using the name passed in on the command line.
+  #
+  def freeze_to_repository
+    File.open(output_dir, 'w') {|fd| fd.puts repository}
+    @out.puts "Project skeleton #{name.inspect} " <<
+              "has been frozen to #{repository.inspect}"
+  end
+
+
+end  # class FreezeCommand
+end  # class App
+end  # module Bones
+
+# EOF