detroit 0.1.0 → 0.2.0

data/lib/detroit/control.rb

@@ -27,14 +27,15 @@ module Detroit
     # Run the command line interface.
     def cli(*argv)
       cli_options = {
-        :schedules => [],
+        :system => nil, :assemblies => [], 
         :trace=>nil, :trial=>nil, :debug=>nil, :quiet=>nil, :verbose=>nil,
         :force=>nil, :multitask=>nil, :skip=>[]
       }
 
-      cli_usage(cli_options).parse!(argv)
+      usage = cli_usage(cli_options)
+      usage.parse!(argv)
 
-      #if /\.schedule$/ =~ argv[0]
+      #if /\.assembly$/ =~ argv[0]
       #  job = argv[1]
       #  begin
       #    application(cli_options).runscript(argv[0], job)
@@ -68,11 +69,11 @@ module Detroit
             options[:skip] << skip
           end
 
-          usage.on('-a', '--assembly=NAME', "Select assembly. Default is `standard'.") do |assembly|
-            options[:assembly] = assembly
+          usage.on('-s', '--system=NAME', "Select assembly system. Default is `standard'.") do |system|
+            options[:system] = system
           end
-          usage.on('-s', '--schedule [FILE]', 'Use specific schedule file(s).') do |file|
-            options[:schedules] << file
+          usage.on('-a', '--assembly [FILE]', 'Use specific assembly file(s).') do |file|
+            options[:assemblies] << file
           end
 
           usage.on('-F', '--force', "Force operations.") do
@@ -87,7 +88,7 @@ module Detroit
             options[:trial] = true
           end
           # TODO: do we really need verbose?
-          usage.on('--verbose', "Provided extra output.") do
+          usage.on('--verbose', "Provide extra output.") do
             options[:verbose] = true
           end
           usage.on('-q', '--quiet', "Run silently.") do
@@ -106,12 +107,16 @@ module Detroit
           usage.on('--warn', "Run with $VERBOSE set to true.") do
             $VERBOSE = true  # wish this were called $WARN
           end
-          usage.on_tail('--help', "Display this help message.") do
-            puts usage
+          usage.on_tail('--help [TOOL]', "Display this help message.") do |tool|
+            if tool
+              application.display_help(tool)
+            else
+              puts usage
+            end
             exit
           end
-          usage.on_tail('--config', "Produce a configuration template.") do
-            puts application.config_template.to_yaml
+          usage.on_tail('-c', '--config TOOL', "Produce a configuration template.") do |tool|
+            puts application.config_template(tool).to_yaml
             exit
           end
         end

data/lib/detroit/core_ext.rb

@@ -42,8 +42,6 @@ end
 
 # TODO: Replace these with facets/shellwords !!!
 
-# TODO: Belongs in Redtools, no?
-
 #
 class Array #:nodoc:
 

data/lib/detroit/custom.rb

@@ -23,6 +23,11 @@ module Detroit
 
     private
 
+    SPECIAL_OPTIONS = %w{
+      service track tracks active priority project 
+      trial trace verbose force quiet
+    }
+
     # Instantiate new custom plugin.
     #
     # FIXME: Custom#initialize seems to be running twice at startup. Why?
@@ -34,14 +39,11 @@ module Detroit
       super(options)
       options.each do |stop, script|
         # skip specific names used for configuration
-        next if stop == 'service'
-        next if stop == 'tracks' or stop == 'track'
-        next if stop == 'active'
-        next if stop == 'priority'
+        next if SPECIAL_OPTIONS.include? stop
         # remaining options are names of track stops
         #tracks.each do |t|
           src = %{
-            def #{stop}
+            def station_#{stop}
               #{script}
             end
           }
@@ -57,9 +59,22 @@ module Detroit
 
     #
     def method_missing(s, *a, &b)
-      super(s, *a, &b) if @context.respond_to?(s)
+      if @context.respond_to?(s)
+        @context.__send__(s,*a,&b)
+      else
+        super(s, *a, &b)
+      end
     end
 
+    public
+
+    #
+    #def respond_to?(name)
+    #  r = super(name)
+    #  return r if r
+    #  @context.respond_to?(s)
+    #end
+
   end
 
 end

data/lib/detroit/service.rb

@@ -5,12 +5,11 @@ module Detroit
   #  @registry ||= {}
   #end
  
-  # Service class wraps a Tool instance.
-  #
-  # TODO: change name ?
+  # Service class wraps a Tool instance when it is made
+  # part of an assembly.
   #
   # TODO: Need to work on how to limit a service's tracks per-assembly.
-  class ServiceWrapper
+  class Service
     attr :key
     attr :tracks
     attr :priority
@@ -52,18 +51,26 @@ module Detroit
 
     # Does the service support the given stop.
     def stop?(name)
-      @service.respond_to?(name)
+      @service.respond_to?("station_#{name}")
     end
 
     # Run the service stop procedure.
-    def invoke(name)
-      @service.__send__(name)  # public_send
+    def invoke(name, stop=nil)
+      sm = @service.method("station_#{name}")  # public_send
+      sm.arity == 0 ? sm.call : sm.call(stop)
     end
 
     #
     def inspect
       "<#{self.class}:#{object_id} @key='#{key}'>"
     end
+
+    #
+    #def self.assemble(name, method=nil)
+    #  define_method("assembly_#{name}") do
+    #    __send__(method || name)  # public_send
+    #  end
+    #end
   end
 
 end

data/lib/detroit/standard_assembly.rb

@@ -1,13 +1,12 @@
 module Detroit
 
-  # Standard assembly is the default. In the vast majority of
-  # cases this is all that will ever be used.
-  assembly :standard do
+  # Standard assembly is the default. In the majority of cases this
+  # is all that will be needed. It represents the workflow of
+  # a developing project (particularly Ruby project).
+  assembly_system :standard do
 
     # Main track.
     #
-    # TODO: Should :install comes before :verify b/c verfication might
-    # require a local installation?
     track :main,
       :prepare,    # prepare services / ensure service requirements
       :generate,   # code generation
@@ -16,8 +15,8 @@ module Detroit
       :analyze,    # perform code analysis
       :document,   # generate documentation
       :package,    # create packages
-      :verify,     # post package verification / integration tests
       :install,    # install the package locally (if need be)
+      :verify,     # post package verification / integration tests
       :publish,    # publish website/documentation
       :release,    # release packages
       :deploy,     # deploy system to servers

data/lib/detroit/tool.rb

@@ -1,5 +1,8 @@
 module Detroit
 
+  # TODO: The plan is to replace most, if not all, of the fileutils
+  # functionality with Ratch when it is ready.
+
   require 'detroit/tool/core_ext'
   require 'detroit/tool/shell_utils'
   require 'detroit/tool/project_utils'
@@ -38,46 +41,59 @@ module Detroit
   # all of the utility methods provided by the regular Tool
   # class.
   class BasicTool
-    # Add an assembly to which the tool applies.
-    # By default the `standard` assembly is implied.
-    def self.assembly(assembly=nil)
-      @assembly ||= []
-      if assembly
-        @assembly << assembly.to_sym
-        @assembly.uniq!
+    class << self
+      # Add an assembly system to which the tool applies.
+      # By default the `standard` ssystem is implied.
+      def assembly_system(assembly=nil)
+        @assembly ||= []
+        if assembly
+          @assembly << assembly.to_sym
+          @assembly.uniq!
+        end
+        @assembly
       end
-      @assembly
-    end
 
-    # Override the `tracks` method to limit the lines a service
-    # will work with by default. Generally this is not used,
-    # and a return value of +nil+ means all lines apply.
-    #--
-    # TODO: Rename to #lines ?
-    #++
-    def self.tracks
-    end
+      # Shorter alias for #assembly_system.
+      alias_method :assembly, :assembly_system
 
-    # Override this method if the tools availability is conditional.
-    def self.available?
-      true
-    end
+      # Override the `tracks` method to limit the lines a service
+      # will work with by default. Generally this is not used,
+      # and a return value of +nil+ means all lines apply.
+      #--
+      # TODO: Rename to #lines ?
+      #++
+      def tracks
+      end
 
-    # Returns list of writer method names.
-    def self.options(service_class=self)
-      service_class.instance_methods.
-        select{ |m| m.to_s =~ /\w+=$/ && !%w{taguri=}.include?(m.to_s) }.
-        map{ |m| m.to_s.chomp('=') }
-    end
+      # Override this method if the tools availability is conditional.
+      def available?
+        true
+      end
 
-    # Returns a Class which is a new subclass of the current class.
-    def self.factory(&block)
-      Class.new(self, &block)
-    end
+      # Returns list of writer method names. This is used for reference.
+      def options(service_class=self)
+        i = service_class.ancestors.index(Tool) ||
+            service_class.ancestors.index(BasicTool)
+        m = []
+        service_class.ancestors[0..i].each do |sc|
+          sc.public_instance_methods(false).each do |pm|
+            next if pm !~ /\w+=$/
+            next if %w{taguri=}.include?(m.to_s)
+            m << pm.to_s.chomp('=')
+          end
+        end
+        m
+      end
 
-    # When inherited, add class to tool registry.
-    def self.inherited(base)
-      Detroit.register_tool(base)
+      # Returns a Class which is a new subclass of the current class.
+      def factory(&block)
+        Class.new(self, &block)
+      end
+
+      # When inherited, add class to tool registry.
+      def inherited(base)
+        Detroit.register_tool(base)
+      end
     end
 
     # TODO: Needed? Rename?
@@ -134,7 +150,7 @@ module Detroit
     end
 
     # TODO: It would be best if an error were raised if an option is not
-    # supported, however for now only a warning will be issued, b/c of 
+    # supported, however for now only a warning will be issued, b/c
     # subclassing makes things more complicated.
     def initialize_options(options)
       @options = options
@@ -183,7 +199,6 @@ module Detroit
       Platform.local.to_s
     end
 
-    # TODO: Is naming_policy really useful?
     # TODO: How to set this in a more universal manner?
     #
     def naming_policy(*policies)

data/lib/detroit/tool/email_utils.rb

@@ -147,7 +147,7 @@ module Detroit
       raise ArgumentError, "missing email field -- mailto"  unless mailto
       raise ArgumentError, "missing email field -- subject" unless subject
 
-      passwd ||= password("#{account} password:")
+      passwd ||= password("#{account} password: ")
 
       mailto = [mailto].flatten.compact
 
@@ -161,16 +161,18 @@ module Detroit
       #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
+        smtp = Net::SMTP.new(server, port)
+
+        if smtp.respond_to?(:enable_starttls_auto)
+          smtp.enable_starttls_auto
+        elsif secure #&& smtp.respond_to?(:enable_tls)
+          smtp.enable_tls
         end
+
+        smtp.start(domain, account, passwd, login) do |smtp|
+          smtp.send_message(msg, from, mailto)
+        end
+
         return mailto
       rescue Exception => e
         return e
@@ -202,7 +204,7 @@ module Detroit
     #
     def require_smtp
       begin
-        require 'facets/net/smtp_tls'
+        require 'net/smtp_tls'
       rescue LoadError
         require 'net/smtp'
       end

data/lib/detroit/tool/shell_utils.rb

@@ -1,5 +1,6 @@
 require 'detroit/tool/core_ext/shell_extensions'
 require 'rbconfig'
+require 'ansi/core'
 
 module Detroit
 
@@ -14,16 +15,26 @@ module Detroit
       @quiet = false
       @trial = false
       @noop  = false
-      @force = false
+      @force = false     
+
       super() if defined?(super)
     end
 
     #
     def initialize_extensions
-      extend(fileutils)
+    #  extend(fileutils)
       super() if defined?(super)
     end
 
+    # Fallback to filutils.
+    def method_missing(s, *a, &b)
+      if fileutils.respond_to?(s)
+        fileutils.send(s, *a, &b)
+      else
+        super(s, *a, &b)
+      end
+    end
+
     # A path is required for shell methods to operate.
     # If no path is set than the current working path is used.
     def path
@@ -35,22 +46,6 @@ module Detroit
       @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
@@ -70,26 +65,63 @@ module Detroit
     def noop?    ; @trial   ; end
     def dryrun?  ; verbose? && noop? ; end
 
+    def silent?  ; @quiet   ; end
+
+    # -- Standard IO ----------------------------------------------------------
+
+    attr_writer :stdout
+    attr_writer :stdin
+    attr_writer :stderr
+
+    def stdout
+      @stdout ||= $stdout
+    end
+
+    def stdin
+      @stdin ||= $stdin
+    end
+
+    def stderr
+      @stdout ||= $stderr
+    end
+
     #
     def print(str=nil)
-      stdout.print(str.to_s) unless quiet?
+      return if silent?
+      stdout.print(str.to_s)
     end
 
     #
     def puts(str=nil)
-      stdout.puts(str.to_s) unless quiet?
+      return if silent?
+      stdout.puts(str.to_s)
+    end
+
+    #
+    def warn(message)
+      return if silent?
+      stderr.puts "WARNING ".ansi(:yellow) + message.to_s
     end
 
-    # TODO: deprecate in favor of #report ?
-    def report(message)
-      stderr.puts message unless quiet?
+    #
+    def status(message)
+      return if silent?
+      stdout.puts "#{message}".ansi(:bold)
     end
 
-    alias_method :status, :report
+    # Same as status.
+    #
+    # @deprecated
+    #   Doubley redundant with #status and #puts.
+    alias report status
 
     # Internal trace report. Only output if in trace mode.
     def trace(message)
-      stderr.puts message if trace?
+      return if silent?
+      if trace?
+        stdout.print "TRIAL RUN " if trial?
+        stdout.puts message
+      end
     end
 
     # Convenient method to get simple console reply.
@@ -107,6 +139,8 @@ module Detroit
       ask(prompt)
     end
 
+    # -- Shell ----------------------------------------------------------------
+
     # Delegate to Ratch::Shell instance.
     #def shell(path=Dir.pwd)
     #  @shell ||= {}
@@ -125,21 +159,28 @@ module Detroit
       trace cmd
       return true if noop?
 
+      success = nil
       if quiet?
-        silently{ system(cmd) }
+        silently{ success = system(cmd) }
       else
-        system(cmd)
+        success = system(cmd)
       end
+      success
     end
 
     # Current ruby binary.
-    RUBY = File.join(::Config::CONFIG['bindir'], ::Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
+    RUBY = (
+      bindir   = ::RbConfig::CONFIG['bindir']
+      rubyname = ::RbConfig::CONFIG['ruby_install_name']
+      File.join(bindir, rubyname).sub(/.*\s.*/m, '"\&"')
+    )
 
     # Shell-out to ruby.
     def ruby(cmd)
       sh RUBY + " " + cmd
     end
 
+    # -- Dir Methods ----------------------------------------------------------
 
     # TODO: Ultimately merge #glob and #multiglob.
     def multiglob(*args, &blk)
@@ -151,25 +192,6 @@ module Detroit
       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
@@ -215,6 +237,25 @@ module Detroit
 
     def utime(*args) ; File.utime(*args) unless noop? ; 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
+
     private # -----------------------------------------------------------------
 
     # Returns FileUtils module based on mode.