TwP-bones 2.3.0

data/lib/bones/app/info_command.rb

@@ -0,0 +1,58 @@
+
+module Bones
+class App
+
+class InfoCommand < Command
+
+  def run( args )
+    parse args
+
+    skeleton_dir = File.join(mrbones_dir, 'data')
+    skeleton_dir = ::Bones.path('data') unless test(?d, skeleton_dir)
+
+    msg  = "\n"
+    msg << "The default project skeleton will be copied from:\n"
+    msg << "    " << skeleton_dir << "\n\n"
+
+    fmt = "    %-12s => %s\n"
+    msg << "Available projects skeletons are:\n"
+    Dir.glob(File.join(mrbones_dir, '*')).sort.each do |fn|
+      next if fn =~ %r/\.archive$/
+      next if File.basename(fn) == 'data'
+
+      if test(?f, fn)
+        msg << fmt % [File.basename(fn), File.read(fn).strip]
+      else
+        msg << "    " << File.basename(fn) << "\n"
+      end
+    end
+
+    @out.puts msg
+    @out.puts
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones info'
+
+    opts.separator ''
+    opts.separator '  Shows information about available skeletons'
+
+    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
+  end
+
+end  # class InfoCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/unfreeze_command.rb

@@ -0,0 +1,53 @@
+
+module Bones
+class App
+
+class UnfreezeCommand < Command
+
+  def run( args )
+    parse args
+
+    fm = FileManager.new(
+      :source => repository || ::Bones.path('data'),
+      :destination => output_dir,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+
+    if fm.archive_destination
+      @out.puts "Project skeleton #{name.inspect} has been unfrozen"
+    else
+      @out.puts "Project skeleton #{name.inspect} is not frozen " <<
+                "(no action taken)"
+    end
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones unfreeze [skeleton_name]'
+
+    opts.separator ''
+    opts.separator "  Removes the named skeleton from the '~/.mrbones/' folder. If a name is"
+    opts.separator "  not given then the default skeleton is removed."
+
+    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
+
+end  # class UnfreezeCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/update_command.rb

@@ -0,0 +1,47 @@
+
+module Bones
+class App
+
+class UpdateCommand < Command
+
+  def run( args )
+    parse args
+
+    raise "'#{output_dir}' does not exist" unless test(?e, output_dir)
+    copy_tasks(File.join(output_dir, 'tasks'))
+
+    msg = "Updated tasks in directory '#{output_dir}'"
+    @out.puts msg
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones update <directory>'
+
+    opts.separator ''
+    opts.separator '  Copy the Mr Bones rake tasks into the project directory'
+
+    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[:output_dir] = args.empty? ? nil : args.join('_')
+
+    if output_dir.nil?
+      @out.puts opts
+      exit 1
+    end
+  end
+
+end  # class CreateCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app.rb

@@ -0,0 +1,92 @@
+
+require 'fileutils'
+require 'optparse'
+require 'erb'
+
+module Bones
+class App
+
+  # 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
+
+  # Create a new main instance using _io_ for standard output and _err_ for
+  # error messages.
+  #
+  def initialize( out = STDOUT, err = STDERR )
+    @out = out
+    @err = err
+  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}"
+      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
+
+  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.
+
+  Usage:
+    bones -h/--help
+    bones -v/--version
+    bones command [options] [arguments]
+
+  Examples:
+    bones create new_project
+    bones freeze -r git://github.com/fudgestudios/bort.git bort
+    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
+
+  Further Help:
+    Each command has a '--help' option that will provide detailed
+    information for that command.
+
+    http://codeforpeople.rubyforge.org/bones/
+
+    MSG
+    nil
+  end
+
+end  # class App
+end  # module Bones
+
+Bones.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/bones/debug.rb

@@ -0,0 +1,71 @@
+
+require 'pp'
+require 'stringio'
+
+module Bones
+
+# Helper module that will pretty print OpenStruct objects. It is used mainly
+# for debugging the Mr Bones project open struct.
+#
+module Debug
+
+  # :stopdoc:
+  KEY_LENGTH = 20
+  VAR_LENGTH = 78 - 6 - KEY_LENGTH
+  SEP = "\n" + ' '*(KEY_LENGTH+6)
+  FMT = "  %-#{KEY_LENGTH}s => %s"
+  # :startdoc:
+
+  # Print all the keys for the given _ostruct_ to stdout. If a _prefix_ is
+  # given, then the open struct keys will be prefixed with this string.
+  #
+  def self.show( ostruct, prefix = '' )
+    sio = StringIO.new
+
+    h = ostruct.instance_variable_get(:@table)
+    h.keys.map {|k| k.to_s}.sort.each do |k|
+      sio.truncate 0
+      next if k =~ %r/^_/o
+
+      val = h[k.to_sym]
+      if val.instance_of?(OpenStruct)
+        self.show(val, prefix + k + '.')
+      else
+        PP.pp(val, sio, VAR_LENGTH)
+        sio.seek 0
+        val = sio.read
+        val = val.split("\n").join(SEP)
+
+        key = prefix + k
+        key[(KEY_LENGTH-3)..-1] = '...' if key.length > KEY_LENGTH
+        puts(FMT % [key, val])
+      end
+    end
+  end
+
+  # Print a single attribute from the given _ostruct_ to stdout. The
+  # attributed is identified by the given _key_.
+  #
+  def self.show_attr( ostruct, key )
+    sio = StringIO.new
+
+    key = key.dup if key.frozen?
+    val = key.split('.').inject(ostruct) {|os,k| os.send(k)}
+
+    if val.instance_of?(OpenStruct)
+      self.show(val, key + '.')
+    else
+      PP.pp(val, sio, VAR_LENGTH)
+      sio.seek 0
+      val = sio.read
+      val = val.split("\n").join(SEP)
+
+      key[(KEY_LENGTH-3)..-1] = '...' if key.length > KEY_LENGTH
+      puts(FMT % [key, val])
+    end
+  end
+
+end  # module Debug
+end  # module Bones
+
+# EOF

data/lib/bones/smtp_tls.rb

@@ -0,0 +1,75 @@
+
+# This code enables SMTPTLS authentication requireed for sending mail
+# via the gmail servers. I found this code via a blog entry from James
+# Britt.
+#
+# http://d.hatena.ne.jp/zorio/20060416
+# http://www.jamesbritt.com/2007/12/18/sending-mail-through-gmail-with-ruby-s-net-smtp
+
+require "openssl"
+require "net/smtp"
+
+Net::SMTP.class_eval do
+  private
+  def do_start(helodomain, user, secret, authtype)
+    raise IOError, 'SMTP session already started' if @started
+
+    if user or secret
+      if 3 == self.method(:check_auth_args).arity
+        check_auth_args(user, secret, authtype)
+      else
+        check_auth_args(user, secret)
+      end
+    end
+
+    sock = timeout(@open_timeout) { TCPSocket.open(@address, @port) }
+    @socket = Net::InternetMessageIO.new(sock)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = STDERR #@debug_output
+
+    check_response(critical { recv_response() })
+    do_helo(helodomain)
+
+    raise 'openssl library not installed' unless defined?(OpenSSL)
+    starttls
+    ssl = OpenSSL::SSL::SSLSocket.new(sock)
+    ssl.sync_close = true
+    ssl.connect
+    @socket = Net::InternetMessageIO.new(ssl)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = STDERR #@debug_output
+    do_helo(helodomain)
+
+    authenticate user, secret, authtype if user
+    @started = true
+  ensure
+    unless @started
+      # authentication failed, cancel connection.
+        @socket.close if not @started and @socket and not @socket.closed?
+      @socket = nil
+    end
+  end
+
+  def do_helo(helodomain)
+    begin
+      if @esmtp
+        ehlo helodomain
+      else
+        helo helodomain
+      end
+    rescue Net::ProtocolError
+      if @esmtp
+        @esmtp = false
+        @error_occured = false
+        retry
+      end
+      raise
+    end
+  end
+
+  def starttls
+    getok('STARTTLS')
+  end
+end
+
+# EOF

data/lib/bones/tasks/ann.rake

@@ -0,0 +1,80 @@
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/lib/bones/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF

data/lib/bones/tasks/gem.rake

@@ -0,0 +1,201 @@
+
+require 'find'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+module Bones
+class GemPackageTask < Rake::PackageTask
+  # Ruby GEM spec containing the metadata for this package.  The
+  # name, version and package_files are automatically determined
+  # from the GEM spec and don't need to be explicitly provided.
+  #
+  attr_accessor :gem_spec
+
+  # Tasks from the Bones gem directory
+  attr_reader :bones_files
+
+  # Create a GEM Package task library.  Automatically define the gem
+  # if a block is given.  If no block is supplied, then +define+
+  # needs to be called to define the task.
+  #
+  def initialize(gem_spec)
+    init(gem_spec)
+    yield self if block_given?
+    define if block_given?
+  end
+
+  # Initialization tasks without the "yield self" or define
+  # operations.
+  #
+  def init(gem)
+    super(gem.name, gem.version)
+    @gem_spec = gem
+    @package_files += gem_spec.files if gem_spec.files
+    @bones_files = []
+
+    local_setup = File.join(Dir.pwd, %w[tasks setup.rb])
+    if !test(?e, local_setup)
+      Dir.glob(::Bones.path(%w[lib bones tasks *])).each {|fn| bones_files << fn}
+    end
+  end
+
+  # Create the Rake tasks and actions specified by this
+  # GemPackageTask.  (+define+ is automatically called if a block is
+  # given to +new+).
+  #
+  def define
+    super
+    task :prereqs
+    task :package => ['gem:prereqs', "#{package_dir_path}/#{gem_file}"]
+    file "#{package_dir_path}/#{gem_file}" => [package_dir_path] + package_files + bones_files do
+      when_writing("Creating GEM") {
+        chdir(package_dir_path) do
+          Gem::Builder.new(gem_spec).build
+          verbose(true) {
+            mv gem_file, "../#{gem_file}"
+          }
+        end
+      }
+    end
+
+    file package_dir_path => bones_files do
+      mkdir_p package_dir rescue nil
+
+      gem_spec.files = (gem_spec.files +
+          bones_files.map {|fn| File.join('tasks', File.basename(fn))}).sort
+
+      bones_files.each do |fn|
+        base_fn = File.join('tasks', File.basename(fn))
+        f = File.join(package_dir_path, base_fn)
+        fdir = File.dirname(f)
+        mkdir_p(fdir) if !File.exist?(fdir)
+        if File.directory?(fn)
+          mkdir_p(f)
+        else
+          raise "file name conflict for '#{base_fn}' (conflicts with '#{fn}')" if test(?e, f)
+          safe_ln(fn, f)
+        end
+      end
+    end
+  end
+  
+  def gem_file
+    if @gem_spec.platform == Gem::Platform::RUBY
+      "#{package_name}.gem"
+    else
+      "#{package_name}-#{@gem_spec.platform}.gem"
+    end
+  end
+end  # class GemPackageTask
+end  # module Bones
+
+namespace :gem do
+
+  PROJ.gem._spec = Gem::Specification.new do |s|
+    s.name = PROJ.name
+    s.version = PROJ.version
+    s.summary = PROJ.summary
+    s.authors = Array(PROJ.authors)
+    s.email = PROJ.email
+    s.homepage = Array(PROJ.url).first
+    s.rubyforge_project = PROJ.rubyforge.name
+
+    s.description = PROJ.description
+
+    PROJ.gem.dependencies.each do |dep|
+      s.add_dependency(*dep)
+    end
+
+    PROJ.gem.development_dependencies.each do |dep|
+      s.add_development_dependency(*dep)
+    end
+
+    s.files = PROJ.gem.files
+    s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+    s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
+
+    s.bindir = 'bin'
+    dirs = Dir["{#{PROJ.libs.join(',')}}"]
+    s.require_paths = dirs unless dirs.empty?
+
+    incl = Regexp.new(PROJ.rdoc.include.join('|'))
+    excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+    excl = Regexp.new(excl.join('|'))
+    rdoc_files = PROJ.gem.files.find_all do |fn|
+                   case fn
+                   when excl; false
+                   when incl; true
+                   else false end
+                 end
+    s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
+    s.extra_rdoc_files = rdoc_files
+    s.has_rdoc = true
+
+    if test ?f, PROJ.test.file
+      s.test_file = PROJ.test.file
+    else
+      s.test_files = PROJ.test.files.to_a
+    end
+
+    # Do any extra stuff the user wants
+    PROJ.gem.extras.each do |msg, val|
+      case val
+      when Proc
+        val.call(s.send(msg))
+      else
+        s.send "#{msg}=", val
+      end
+    end
+  end  # Gem::Specification.new
+
+  Bones::GemPackageTask.new(PROJ.gem._spec) do |pkg|
+    pkg.need_tar = PROJ.gem.need_tar
+    pkg.need_zip = PROJ.gem.need_zip
+  end
+
+  desc 'Show information about the gem'
+  task :debug => 'gem:prereqs' do
+    puts PROJ.gem._spec.to_ruby
+  end
+
+  desc 'Write the gemspec '
+  task :spec => 'gem:prereqs' do
+    File.open("#{PROJ.name}.gemspec", 'w') do |f|
+      f.write PROJ.gem._spec.to_ruby
+    end
+  end
+
+  desc 'Install the gem'
+  task :install => [:clobber, 'gem:package'] do
+    sh "#{SUDO} #{GEM} install --local pkg/#{PROJ.gem._spec.full_name}"
+
+    # use this version of the command for rubygems > 1.0.0
+    #sh "#{SUDO} #{GEM} install --no-update-sources pkg/#{PROJ.gem._spec.full_name}"
+  end
+
+  desc 'Uninstall the gem'
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PROJ.name)
+    if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+      sh "#{SUDO} #{GEM} uninstall --version '#{PROJ.version}' --ignore-dependencies --executables #{PROJ.name}"
+    end
+  end
+
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
+  desc 'Cleanup the gem'
+  task :cleanup do
+    sh "#{SUDO} #{GEM} cleanup #{PROJ.gem._spec.name}"
+  end
+end  # namespace :gem
+
+
+desc 'Alias to gem:package'
+task :gem => 'gem:package'
+
+task :clobber => 'gem:clobber_package'
+remove_desc_for_task 'gem:clobber_package'
+
+# EOF