bones 2.5.1 → 3.0.0

data/lib/bones/app/info.rb

@@ -0,0 +1,39 @@
+
+module Bones::App
+class Info < Command
+
+  def self.initialize_info
+    synopsis 'bones info'
+    summary 'show information about available skeletons'
+    description 'Shows information about available skeletons.'
+  end
+
+  def run
+    skeleton_dir = File.join(mrbones_dir, DEFAULT_SKELETON)
+    skeleton_dir = ::Bones.path(DEFAULT_SKELETON) 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) == DEFAULT_SKELETON
+
+      if test(?f, fn)
+        msg << fmt % [File.basename(fn), File.read(fn).strip]
+      else
+        msg << "    " << File.basename(fn) << "\n"
+      end
+    end
+
+    stdout.puts msg
+    stdout.puts
+  end
+
+end  # class Info
+end  # module Bones::App
+
+# EOF

data/lib/bones/app/unfreeze.rb

@@ -0,0 +1,44 @@
+
+module Bones::App
+class Unfreeze < Command
+
+  def self.initialize_unfreeze
+    synopsis 'bones unfreeze [skeleton_name]'
+
+    summary 'remove a skeleton from ~/.mrbones/'
+
+    description <<-__
+Removes the named skeleton from the '~/.mrbones/' folder. If a name is
+not given then the default skeleton is removed.
+    __
+
+    option(standard_options[:verbose])
+  end
+
+  def run
+    fm = FileManager.new(
+      :source => repository || ::Bones.path(DEFAULT_SKELETON),
+      :destination => output_dir,
+      :stdout => stdout,
+      :stderr => stderr,
+      :verbose => verbose?
+    )
+
+    if fm.archive_destination
+      stdout.puts "Project skeleton #{name.inspect} has been unfrozen"
+    else
+      stdout.puts "Project skeleton #{name.inspect} is not frozen " <<
+                  "(no action taken)"
+    end
+  end
+
+  def parse( args )
+    opts = super args
+    config[:name] = args.empty? ? DEFAULT_SKELETON : args.join('_')
+    config[:output_dir] = File.join(mrbones_dir, name)
+  end
+
+end  # class Unfreeze
+end  # module Bones::App
+
+# EOF

data/lib/bones/colors.rb

@@ -0,0 +1,54 @@
+
+module Bones::Colors
+  extend self
+
+  COLOR_CODES = {
+    :clear         =>   0,
+    :reset         =>   0,     # synonym for :clear
+    :bold          =>   1,
+    :dark          =>   2,
+    :italic        =>   3,     # not widely implemented
+    :underline     =>   4,
+    :underscore    =>   4,     # synonym for :underline
+    :blink         =>   5,
+    :rapid_blink   =>   6,     # not widely implemented
+    :negative      =>   7,     # no reverse because of String#reverse
+    :concealed     =>   8,
+    :strikethrough =>   9,     # not widely implemented
+    :black         =>  30,
+    :red           =>  31,
+    :green         =>  32,
+    :yellow        =>  33,
+    :blue          =>  34,
+    :magenta       =>  35,
+    :cyan          =>  36,
+    :white         =>  37,
+    :on_black      =>  40,
+    :on_red        =>  41,
+    :on_green      =>  42,
+    :on_yellow     =>  43,
+    :on_blue       =>  44,
+    :on_magenta    =>  45,
+    :on_cyan       =>  46,
+    :on_white      =>  47
+  }
+
+  COLOR_CODES.each { |name,code|
+    module_eval <<-CODE
+      def #{name.to_s}( str )
+        "\e[#{code}m\#{str}\e[0m"
+      end
+    CODE
+  }
+
+  def colorize( str, *args )
+    args.each { |name|
+      code = COLOR_CODES[name]
+      next if code.nil?
+      str = "\e[#{code}m#{str}\e[0m"
+    }
+    str
+  end
+end  # module Bones::Colors
+
+# EOF

data/lib/bones/gem_package_task.rb

@@ -0,0 +1,71 @@
+
+require 'find'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+class Bones::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
+
+  # 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
+  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 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 do
+      mkdir_p package_dir rescue nil
+    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 Bones::GemPackageTask
+
+# EOF

data/lib/bones/helpers.rb

@@ -0,0 +1,93 @@
+
+module Bones::Helpers
+
+  DEV_NULL = File.exist?('/dev/null') ? '/dev/null' : 'NUL:'
+  SUDO = if system("which sudo > #{DEV_NULL} 2>&1") then 'sudo'
+         else '' end unless defined? SUDO
+  RCOV = "#{RUBY} -S rcov"
+  RDOC = "#{RUBY} -S rdoc"
+  GEM  = "#{RUBY} -S gem"
+  HAVE_SVN = (Dir.entries(Dir.pwd).include?('.svn') and
+              system("svn --version 2>&1 > #{DEV_NULL}"))
+
+  HAVE = Hash.new(false)
+
+  def have?( key, &block )
+    return HAVE[key] if block.nil?
+    HAVE[key] = block.call
+  end
+
+  def quiet( &block )
+    io = [STDOUT.dup, STDERR.dup]
+    STDOUT.reopen DEV_NULL
+    STDERR.reopen DEV_NULL
+    block.call
+  ensure
+    STDOUT.reopen io.first
+    STDERR.reopen io.last
+    io.each {|x| x.close}
+  end
+
+  # Reads a file at +path+ and spits out an array of the +paragraphs+
+  # specified.
+  #
+  #    changes = paragraphs_of('History.txt', 0..1).join("\n\n")
+  #    summary, *description = paragraphs_of('README.txt', 3, 3..8)
+  #
+  def paragraphs_of( path, *paragraphs )
+    title = String === paragraphs.first ? paragraphs.shift : nil
+    ary = File.read(path).delete("\r").split(/\n\n+/)
+
+    result = if title
+      tmp, matching = [], false
+      rgxp = %r/^=+\s*#{Regexp.escape(title)}/i
+      paragraphs << (0..-1) if paragraphs.empty?
+
+      ary.each do |val|
+        if val =~ rgxp
+          break if matching
+          matching = true
+          rgxp = %r/^=+/i
+        elsif matching
+          tmp << val
+        end
+      end
+      tmp
+    else ary end
+
+    result.values_at(*paragraphs)
+  end
+
+  # Find a rake task using the task name and remove any description text. This
+  # will prevent the task from being displayed in the list of available tasks.
+  #
+  def remove_desc_for_task( names )
+    Array(names).each do |task_name|
+      task = Rake.application.tasks.find {|t| t.name == task_name}
+      next if task.nil?
+      task.instance_variable_set :@comment, nil
+    end
+  end
+
+end  # module Bones::Helpers
+
+# We need a "valid" method thtat determines if a string is suitable for use
+# in the gem specification.
+#
+class Object
+  def valid?
+    return !(self.empty? or self == "\000") if self.respond_to?(:to_str)
+    return false
+  end
+
+  # Adds the given arguments to the include path if they are not already there
+  #
+  def ensure_in_path( *args )
+    args.each do |path|
+      path = File.expand_path(path)
+      $:.unshift(path) if test(?d, path) and not $:.include?(path)
+    end
+  end
+end
+
+# EOF

data/lib/bones/plugins/ann.rb

@@ -0,0 +1,166 @@
+
+module Bones::Plugins::Ann
+  include ::Bones::Helpers
+  extend self
+
+  module Syntax
+    def use_gmail( user = nil )
+      email = ::Bones.config.ann.email
+      user ||= ::Bones.config.email
+
+      email.username  user
+      email.server    'smtp.gmail.com'
+      email.port      587
+      email.authtype  :plain
+    end
+  end
+
+  def initialize_ann
+    ::Bones.config {
+      desc 'Configuration for creating and mailing an announcement message.'
+      ann {
+        file  'announcement.txt', :desc => <<-__
+          When announcing a release of your project the announcement text will
+          be written to this file.
+        __
+
+        text  nil, :desc => 'Extra text to be appended to the announcement.'
+
+        paragraphs  Array.new, :desc => <<-__
+          Array of paragraphs from the README file to include in the
+          announcement. The paragraphs are identified by their heading name in
+          the README, but when listed here they can be given as lowercase or
+          uppercase.
+        __
+
+        desc <<-__
+          Configuration for e-mailing the announcement.
+
+          A convenience method is provided for configuring Mr Bones to use
+          gmail for sending project announcements. The project's e-mail
+          address isused by default if a gmail username is not supplied.
+          |
+          |  use_gmail
+          |  use_gmail 'username'
+          |
+          Use the latter form of the method is your gmail username is
+          different then the project's e-mail address.
+        __
+        email {
+          from  nil, :desc => <<-__
+            The name to show on the 'from' line of the annoucement e-mail.
+            This will default to the author name or the project e-mail if an
+            author is not specified.
+          __
+
+          to  %w(ruby-talk@ruby-lang.org), :desc => 'An array of e-mail recipients.'
+
+          server  'localhost', :desc => 'The server used to send the announcement e-mail.'
+
+          port  25, :desc => 'The server port number to connect to.'
+
+          domain  ENV['HOSTNAME'], :desc => <<-__
+            The originating domain of the e-mail. This safely deafaults to the
+            local hostname.
+          __
+
+          username  nil, :desc => 'The e-mail account name used to log into the e-mail server.'
+
+          password  nil, :desc => 'The e-mail password used to log into the e-mail server.'
+
+          authtype  :plain, :desc => <<-__
+            The authentication type used by the e-mail server. This should be
+            one of :plain, :login, or :cram_md5. See the documentation on the
+            Net::SMTP class for more information.
+          __
+        }
+      }
+    }
+
+    have?(:ann) { true }
+  end
+
+  def post_load
+    config = ::Bones.config
+
+    config.exclude << "^#{Regexp.escape(config.ann.file)}$"
+    config.ann.email.from     ||= Array(config.authors).first || config.email
+    config.ann.email.username ||= config.email
+    config.ann.email.domain   ||= 'localhost'
+  end
+
+  def define_tasks
+    config = ::Bones.config
+    namespace :ann do
+
+      # A prerequisites task that all other tasks depend upon
+      task :prereqs
+
+      file config.ann.file do
+        ann = config.ann
+        puts "Generating #{ann.file}"
+        File.open(ann.file,'w') do |fd|
+          fd.puts("#{config.name} version #{config.version}")
+          fd.puts("    by #{Array(config.authors).first}") if config.authors
+          fd.puts("    #{config.url}") if config.url.valid?
+          fd.puts("    (the \"#{config.release_name}\" release)") if config.release_name
+          fd.puts
+          fd.puts("== DESCRIPTION")
+          fd.puts
+          fd.puts(config.description)
+          fd.puts
+          fd.puts(config.changes.sub(%r/^.*$/, '== CHANGES'))
+          fd.puts
+          ann.paragraphs.each do |p|
+            fd.puts "== #{p.upcase}"
+            fd.puts
+            fd.puts paragraphs_of(config.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', config.ann.file]
+
+      desc "Send an email announcement"
+      task :email => ['ann:prereqs', config.ann.file] do
+        ann = config.ann
+        email = config.ann.email
+
+        from = email.from
+        to   = Array(email.to)
+
+        ### build a mail header for RFC 822
+        rfc822msg =  "From: #{from}\n"
+        rfc822msg << "To: #{to.join(',')}\n"
+        rfc822msg << "Subject: [ANN] #{config.name} #{config.version}"
+        rfc822msg << " (#{config.release_name})" if config.release_name
+        rfc822msg << "\n"
+        rfc822msg << "Date: #{Time.new.rfc822}\n"
+        rfc822msg << "Message-Id: "
+        rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{email.domain}>\n\n"
+        rfc822msg << File.read(ann.file)
+
+        params = [:server, :port, :domain, :username, :password, :authtype].map { |key| email[key] }
+
+        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 << config.ann.file
+  end
+
+end  # module Bones::Plugins::Ann
+
+# EOF