detroit 0.1.0

data/lib/detroit/tool/core_ext/to_yamlfrag.rb

@@ -0,0 +1,9 @@
+class Object
+
+  #
+  def to_yamlfrag
+    to_yaml.sub("---",'').rstrip
+  end
+
+end
+

data/lib/detroit/tool/core_ext/unfold_paragraphs.rb

@@ -0,0 +1,27 @@
+# TODO: Replace with facets/string/unfold
+
+class String
+
+  #
+  def unfold_paragraphs
+    blank = false
+    text  = ''
+    split(/\n/).each do |line|
+      if /\S/ !~ line
+        text << "\n\n"
+        blank = true
+      else
+        if /^(\s+|[*])/ =~ line
+          text << (line.rstrip + "\n")
+        else
+          text << (line.rstrip + " ")
+        end
+        blank = false
+      end
+    end
+    text = text.gsub("\n\n\n","\n\n")
+    return text
+  end
+
+end
+

data/lib/detroit/tool/email_utils.rb

@@ -0,0 +1,288 @@
+module Detroit
+
+  # The Mail utility module provides an easy to use +email+ method.
+  module EmailUtils
+
+    # Email function to easily send out an email.
+    #
+    # Settings:
+    #
+    #     subject      Subject of email message.
+    #     from         Message FROM address [email].
+    #     to           Email address to send announcemnt.
+    #     server       Email server to route message.
+    #     port         Email server's port.
+    #     domain       Email server's domain name.
+    #     account      Email account name if needed.
+    #     password     Password for login..
+    #     login        Login type: plain, cram_md5 or login [plain].
+    #     secure       Uses TLS security, true or false? [false]
+    #     message      Mesage to send -or-
+    #     file         File that contains message.
+    #
+    def email(options)
+      #options[:file] = localize(options[:file]) if options[:file]
+      emailer = Emailer.new(options.rekey)
+      success = emailer.email
+      if Exception === success
+        puts "Email failed: #{success.message}."
+      else
+        puts "Email sent successfully to #{success.join(';')}."
+      end
+    end
+
+  end
+
+  # Emailer class makes it easy send out an email.
+  #
+  # Settings:
+  #
+  #     subject      Subject of email message.
+  #     from         Message FROM address [email].
+  #     to           Email address to send announcemnt.
+  #     server       Email server to route message.
+  #     port         Email server's port.
+  #     port_secure  Email server's port.
+  #     domain       Email server's domain name.
+  #     account      Email account name if needed.
+  #     password     Password for login..
+  #     login        Login type: plain, cram_md5 or login [plain].
+  #     secure       Uses TLS security, true or false? [false]
+  #     message      Mesage to send -or-
+  #     file         File that contains message.
+  #
+  class Emailer
+
+    class << self
+      # Used for caching password between usages.
+      attr_accessor :password
+
+      #
+      def environment_options
+        options = {}
+        options[:server]   = ENV['EMAIL_SERVER']
+        options[:from]     = ENV['EMAIL_FROM']
+        options[:account]  = ENV['EMAIL_ACCOUNT'] || ENV['EMAIL_FROM']
+        options[:password] = ENV['EMAIL_PASSWORD']
+        options[:port]     = ENV['EMAIL_PORT']
+        options[:domain]   = ENV['EMAIL_DOMAIN']
+        options[:login]    = ENV['EMAIL_LOGIN']
+        options[:secure]   = ENV['EMAIL_SECURE']
+        options
+      end
+
+      def new_with_environment(options={})
+        environment_options.merge(options.rekey)
+        new(options)
+      end
+    end
+
+    attr_accessor :server
+    attr_accessor :port
+    attr_accessor :account
+    attr_accessor :passwd
+    attr_accessor :login
+    attr_accessor :secure
+    attr_accessor :domain
+    attr_accessor :from
+    attr_accessor :mailto
+    attr_accessor :subject
+    attr_accessor :message
+
+    #
+
+    #
+    def initialize(options={})
+      require_smtp
+
+      options = options.rekey
+
+      if not options[:server]
+        options = self.class.environment_options.merge(options)
+      end
+
+      @mailto    = options[:to] || options[:mailto]
+
+      @from      = options[:from]
+      @message   = options[:message]
+      @subject   = options[:subject]
+      @server    = options[:server]
+      @account   = options[:account]
+      @passwd    = options[:password]
+      @login     = options[:login]
+      @secure    = options[:secure] #.to_b
+      @domain    = options[:domain]
+      @port      = options[:port]
+
+      @port    ||= secure ? 465 : 25
+      @port = @port.to_i
+
+      @account ||= @from
+
+      @login   ||= :plain
+      @login = @login.to_sym
+
+      @passwd ||= self.class.password
+
+      @domain ||= @server
+
+      # save the password for later use
+      self.class.password = @passwd
+    end
+
+    #
+
+    def email(options={})
+      options.rekey
+
+      message = options[:message] || self.message
+      subject = options[:subject] || self.subject
+      from    = options[:from]    || self.from
+      mailto  = options[:mailto]  || options[:to] || self.mailto
+
+      raise ArgumentError, "missing email field -- server"  unless server
+      raise ArgumentError, "missing email field -- account" unless account
+
+      raise ArgumentError, "missing email field -- from"    unless from
+      raise ArgumentError, "missing email field -- mailto"  unless mailto
+      raise ArgumentError, "missing email field -- subject" unless subject
+
+      passwd ||= password("#{account} password:")
+
+      mailto = [mailto].flatten.compact
+
+      msg = ""
+      msg << "From: #{from}\n"
+      msg << "To: #{mailto.join(';')}\n"
+      msg << "Subject: #{subject}\n"
+      msg << ""
+      msg << message
+
+      #p server, port, domain, account, passwd, login, secure if verbose?
+
+      begin
+        if Net::SMTP.respond_to?(:enable_tls) && secure
+          Net::SMTP.enable_tls
+          Net::SMTP.start(server, port, domain, account, passwd, login, secure) do |smtp|
+            smtp.send_message(msg, from, mailto)
+          end
+        else
+          Net::SMTP.start(server, port, domain, account, passwd, login) do |smtp|
+            smtp.send_message(msg, from, mailto)
+          end
+        end
+        return mailto
+      rescue Exception => e
+        return e
+      end
+    end
+
+    # Ask for a password.
+    #
+    # FIXME: Does not hide password.
+
+    def password(msg=nil)
+      msg ||= "Enter Password: "
+      inp = ''
+
+      $stdout << msg
+
+      inp = STDIN.gets.chomp
+
+      #begin
+      #  system "stty -echo"
+      #  inp = gets.chomp
+      #ensure
+      #  system "stty echo"
+      #end
+
+      return inp
+    end
+
+    #
+    def require_smtp
+      begin
+        require 'facets/net/smtp_tls'
+      rescue LoadError
+        require 'net/smtp'
+      end
+    end
+
+  end
+
+end
+
+
+
+=begin
+    # Email function to easily send out an email.
+    #
+    # Settings:
+    #
+    #     subject      Subject of email message.
+    #     from         Message FROM address [email].
+    #     to           Email address to send announcemnt.
+    #     server       Email server to route message.
+    #     port         Email server's port.
+    #     domain       Email server's domain name.
+    #     account      Email account name if needed.
+    #     password     Password for login..
+    #     login        Login type: plain, cram_md5 or login [plain].
+    #     secure       Uses TLS security, true or false? [false]
+    #     message      Mesage to send -or-
+    #     file         File that contains message.
+    #
+    def email(message, settings)
+      settings ||= {}
+      settings.rekey!
+
+      server    = settings[:server]
+      account   = settings[:account]  || ENV['EMAIL_ACCOUNT']
+      passwd    = settings[:password] || ENV['EMAIL_PASSWORD']
+      login     = settings[:login].to_sym
+      subject   = settings[:subject]
+      mail_to   = settings[:to]     || settings[:mail_to]
+      mail_from = settings[:from]   || settings[:mail_from]
+      secure    = settings[:secure]
+      domain    = settings[:domain] || server
+
+      port    ||= (secure ? 465 : 25)
+      account ||= mail_from
+      login   ||= :plain
+
+      #mail_to = nil if mail_to.empty?
+
+      raise ArgumentError, "missing email field -- server"  unless server
+      raise ArgumentError, "missing email field -- account" unless account
+      raise ArgumentError, "missing email field -- subject" unless subject
+      raise ArgumentError, "missing email field -- to"      unless mail_to
+      raise ArgumentError, "missing email field -- from"    unless mail_from
+
+      passwd ||= password(account)
+
+      mail_to = [mail_to].flatten.compact
+
+      msg = ""
+      msg << "From: #{mail_from}\n"
+      msg << "To: #{mail_to.join(';')}\n"
+      msg << "Subject: #{subject}\n"
+      msg << ""
+      msg << message
+
+      begin
+        Net::SMTP.enable_tls if Net::SMTP.respond_to?(:enable_tls) and secure
+        Net::SMTP.start(server, port, domain, account, passwd, login) do |s|
+          s.send_message( msg, mail_from, mail_to )
+        end
+        puts "Email sent successfully to #{mail_to.join(';')}."
+        return true
+      rescue => e
+        if trace?
+          raise e
+        else
+          abort "Email delivery failed."
+        end
+      end
+    end
+=end
+

data/lib/detroit/tool/project_utils.rb

@@ -0,0 +1,41 @@
+module Detroit
+
+  #
+  require 'pom'
+
+  #
+  module ProjectUtils
+
+    # Common access to project.
+    def self.project(path=Dir.pwd)
+      if root = ::POM::Project.root(path)
+        @@projects ||= {}
+        @@projects[root] ||= ::POM::Project.new(root)
+      else
+        nil # ?
+      end
+    end
+
+    #
+    def project(path=Dir.pwd)
+      @project ||= ProjectUtils.project(path)
+    end
+
+    # Set project manutally.
+    def project=(proj)
+      @project = proj
+    end
+
+    #
+    def metadata
+      project.metadata
+    end
+
+    #
+    def root
+      project.root
+    end
+
+  end
+
+end

data/lib/detroit/tool/shell_utils.rb

@@ -0,0 +1,235 @@
+require 'detroit/tool/core_ext/shell_extensions'
+require 'rbconfig'
+
+module Detroit
+
+  # ShellUtils provides the whole slew of FileUtils,
+  # FileTest and File class methods in a single module
+  # and modifies methods according to noop? and verbose?
+  # options.
+  module ShellUtils
+
+    #
+    def initialize_extension_defaults
+      @quiet = false
+      @trial = false
+      @noop  = false
+      @force = false
+      super() if defined?(super)
+    end
+
+    #
+    def initialize_extensions
+      extend(fileutils)
+      super() if defined?(super)
+    end
+
+    # A path is required for shell methods to operate.
+    # If no path is set than the current working path is used.
+    def path
+      @path ||= Dir.pwd
+    end
+
+    # Set shell path.
+    def path=(dir)
+      @path = dir
+    end
+
+    attr_writer :stdout
+    attr_writer :stdin
+    attr_writer :stderr
+
+    def stdout
+      @stdout ||= $stdout
+    end
+
+    def stdin
+      @stdin ||= $stdin
+    end
+
+    def stderr
+      @stdout ||= $stderr
+    end
+
+    attr_writer :force
+    attr_writer :quiet
+    attr_writer :trace
+    attr_writer :trial
+    attr_writer :debug
+    attr_writer :verbose
+
+    def force?   ; @force   ; end
+
+    def quiet?   ; @quiet   ; end
+    def trial?   ; @trial   ; end
+
+    def trace?   ; @trace   ; end
+    def debug?   ; @debug   ; end
+
+    def verbose? ; @verbose ; end
+    def noop?    ; @trial   ; end
+    def dryrun?  ; verbose? && noop? ; end
+
+    #
+    def print(str=nil)
+      stdout.print(str.to_s) unless quiet?
+    end
+
+    #
+    def puts(str=nil)
+      stdout.puts(str.to_s) unless quiet?
+    end
+
+    # TODO: deprecate in favor of #report ?
+    def report(message)
+      stderr.puts message unless quiet?
+    end
+
+    alias_method :status, :report
+
+    # Internal trace report. Only output if in trace mode.
+    def trace(message)
+      stderr.puts message if trace?
+    end
+
+    # Convenient method to get simple console reply.
+    def ask(question)
+      stdout.print "#{question} "
+      stdout.flush
+      input = stdin.gets #until inp = stdin.gets ; sleep 1 ; end
+      input.strip
+    end
+
+    # TODO: Until we have better support for getting input across
+    # platforms, we are using #ask for passwords too.
+    def password(prompt=nil)
+      prompt ||= "Enter Password: "
+      ask(prompt)
+    end
+
+    # Delegate to Ratch::Shell instance.
+    #def shell(path=Dir.pwd)
+    #  @shell ||= {}
+    #  @shell[path] ||= (
+    #    mode = {
+    #      :noop    => trial?,
+    #      :verbose => trace? || (trial? && !quiet?),
+    #      :quiet   => quiet?
+    #    }
+    #    Ratch::Shell.new(path, mode)
+    #  )
+    #end
+
+    # Shell runner.
+    def sh(cmd)
+      trace cmd
+      return true if noop?
+
+      if quiet?
+        silently{ system(cmd) }
+      else
+        system(cmd)
+      end
+    end
+
+    # Current ruby binary.
+    RUBY = File.join(::Config::CONFIG['bindir'], ::Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
+
+    # Shell-out to ruby.
+    def ruby(cmd)
+      sh RUBY + " " + cmd
+    end
+
+
+    # TODO: Ultimately merge #glob and #multiglob.
+    def multiglob(*args, &blk)
+      Dir.multiglob(*args, &blk)
+    end
+
+    #
+    def multiglob_r(*args, &blk)
+      Dir.multiglob_r(*args, &blk)
+    end
+
+    # -- File IO Shortcuts ----------------------------------------------------
+
+    # Read file.
+    def read(path)
+      File.read(path)
+    end
+
+    # Write file.
+    def write(path, text)
+      $stderr.puts "write #{path}" if trace?
+      File.open(path, 'w'){ |f| f << text } unless noop?
+    end
+
+    # Append to file.
+    def append(path, text)
+      $stderr.puts "append #{path}" if trace?
+      File.open(path, 'a'){ |f| f << text } unless noop?
+    end
+
+    # -- File Testing ---------------------------------------------------------
+
+    def size(path)             ; FileTest.size(path)             ; end
+    def size?(path)            ; FileTest.size?(path)            ; end
+    def directory?(path)       ; FileTest.directory?(path)       ; end
+    def symlink?(path)         ; FileTest.symlink?(path)         ; end
+    def readable?(path)        ; FileTest.readable?(path)        ; end
+    def chardev?(path)         ; FileTest.chardev?(path)         ; end
+    def exist?(path)           ; FileTest.exist?(path)           ; end
+    def exists?(path)          ; FileTest.exists?(path)          ; end
+    def zero?(path)            ; FileTest.zero?(path)            ; end
+    def pipe?(path)            ; FileTest.pipe?(path)            ; end
+    def file?(path)            ; FileTest.file?(path)            ; end
+    def sticky?(path)          ; FileTest.sticky?(path)          ; end
+    def blockdev?(path)        ; FileTest.blockdev?(path)        ; end
+    def grpowned?(path)        ; FileTest.grpowned?(path)        ; end
+    def setgid?(path)          ; FileTest.setgid?(path)          ; end
+    def setuid?(path)          ; FileTest.setuid?(path)          ; end
+    def socket?(path)          ; FileTest.socket?(path)          ; end
+    def owned?(path)           ; FileTest.owned?(path)           ; end
+    def writable?(path)        ; FileTest.writable?(path)        ; end
+    def executable?(path)      ; FileTest.executable?(path)      ; end
+
+    def safe?(path)            ; FileTest.safe?(path)            ; end
+
+    def relative?(path)        ; FileTest.relative?(path)        ; end
+    def absolute?(path)        ; FileTest.absolute?(path)        ; end
+
+    def writable_real?(path)   ; FileTest.writable_real?(path)   ; end
+    def executable_real?(path) ; FileTest.executable_real?(path) ; end
+    def readable_real?(path)   ; FileTest.readable_real?(path)   ; end
+
+    def identical?(path, other)
+      FileTest.identical?(path, other)
+    end
+    alias_method :compare_file, :identical?
+
+    # -- File Methods ---------------------------------------------------------
+
+    def atime(*args) ; File.ctime(*args) ; end
+    def ctime(*args) ; File.ctime(*args) ; end
+    def mtime(*args) ; File.mtime(*args) ; end
+
+    def utime(*args) ; File.utime(*args) unless noop? ; end
+
+    private # -----------------------------------------------------------------
+
+    # Returns FileUtils module based on mode.
+    def fileutils
+      if dryrun?
+        ::FileUtils::DryRun
+      elsif noop? or trial?
+        ::FileUtils::Noop
+      elsif trace?
+        ::FileUtils::Verbose
+      else
+        ::FileUtils
+      end
+    end
+
+  end
+
+end