detroit 0.3.0 → 0.4.0

data/bin/detroit

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require 'detroit'
 begin
-  Detroit.cli(*ARGV)
+  Detroit::Toolchain.cli(ARGV)
 rescue => err
   raise err #if $DEBUG
   $stderr.puts err

data/lib/detroit.rb

@@ -11,54 +11,126 @@ module Detroit
   def self.const_missing(name)
     metadata[name.to_s.downcase] || super(name)
   end
-
-  # TODO: Only here b/c of bug in Ruby 1.8.x
-  #VERSION = "0.3.0"
 end
 
-# Erb is used to to script YAML-based schedule files.
-require 'erb'
-
-# OptionParser is used for command line parsing.
-require 'optparse'
+require 'pathname'
+require 'erb'           # Erb is used to to script YAML-based schedule files.
+require 'optparse'      # OptionParser is used for command line parsing.
+require 'yaml'          # Yea like we don't all ride a YAML.
 
-# Yea like we don't all ride a YAML.
-require 'yaml'
-
-# The ANSI gem is used to colorize terminal output.
-require 'ansi/terminal'
+require 'indexer'       # Indexer is used to provide project metadata.
+require 'ansi/terminal' # The ANSI gem is used to colorize terminal output.
 require 'ansi/code'
 
-# The parallel gem is used to (optionally) multitask services.
+# The optional parallel gem is used to multitask services.
 begin
   require 'parallel'
 rescue LoadError
 end
 
-# POM is used to access project metadata.
-require 'pom'
-
-# And all the rest is Detroit, baby.
-if RUBY_VERSION > '1.9'
-  require_relative 'detroit/core_ext'
-  require_relative 'detroit/config'
-  require_relative 'detroit/service'
-  require_relative 'detroit/tool'
-  require_relative 'detroit/assembly_system'
-  require_relative 'detroit/standard_assembly'
-  require_relative 'detroit/control'
-  require_relative 'detroit/application'
-  require_relative 'detroit/assembly'
-  require_relative 'detroit/custom'
-else
-  require 'detroit/core_ext'
-  require 'detroit/config'
-  require 'detroit/service'
-  require 'detroit/tool'
-  require 'detroit/assembly_system'
-  require 'detroit/standard_assembly'
-  require 'detroit/control'
-  require 'detroit/application'
-  require 'detroit/assembly'
-  require 'detroit/custom'
+require_relative 'detroit/core_ext'
+require_relative 'detroit/project'
+require_relative 'detroit/toolchain' #runner
+require_relative 'detroit/exec'
+
+require_relative 'detroit/basic_utils'
+require_relative 'detroit/shell_utils'
+require_relative 'detroit/email_utils'
+require_relative 'detroit/ruby_utils'
+
+require_relative 'detroit/basic_tool'
+
+
+module Detroit
+
+  #
+  # Tool registry.
+  #
+  def self.tools
+    @tools ||= {}
+  end
+
+  #
+  # Define tool method.
+  #
+  def self.define_tool_method(name, tool_class)
+    (class << self; self; end).class_eval do
+      # raise or skip if method_defined?(name)
+      define_method(name) do |*a, &b|
+        tool_class.new(*a, &b)
+      end
+    end
+  end
+
+  #
+  # Add tool class to registry. If class name ends in `Tool` or `Base`
+  # it will be considered a reusable base class and not be added.
+  #
+  def self.register_tool(tool_class)
+    name = tool_class.basename
+    return if name.nil?
+    return if name.empty?
+    return if name =~ /Tool$/
+    return if name =~ /Base$/
+    tools[name.downcase] = tool_class
+    Tools.const_set(name, tool_class)
+    Detroit.define_tool_method(name, tool_class)
+    return tool_class
+  end
+
+=begin
+  ##
+  # Per-project configuration for detroit.
+  #
+  # TODO: Do we really need this?
+  class Config < BasicObject
+    FILE = ".detroit"
+
+    def initialize(root)
+      @file = Dir.glob(root + FILE).first
+
+      if @file
+        @data = YAML.load_file(@file)
+      else
+        @data = {}
+      end
+    end
+
+    def method_missing(s, *a, &b)
+      @data[s.to_s]
+    end
+  end
+=end
+
+  ##
+  # The Tools module provides an isolated namespace for Detoit's tools.
+  # This allows for general use of these tools by other applications,
+  # simply by including the Detroit::Tools module into their own namespace.
+  #
+  module Tools
+  end
+
+  ##
+  # The common base class for tools. Tool is a subclass of BasicTool that
+  # adds additional utility methods, in particular it adds {ShellUtils}.
+  # Unless there is a specific reason not to do so, this is the class 
+  # that specific tool classes should subclass.
+  #
+  # A good tool will check to see if the state of the project is *current*
+  # or not to know if some stage of the tool needs to be used or not.
+  # For example a documentation# tool can look to see if any the files
+  # it would document are newer that the previous generated set of document
+  # file. In this case it can output a message explaining that the action
+  # was not needed. For example, the RDoc tool outputs the message:
+  # "RDocs are current (path/to/rdocs)". The tool can also support the 
+  # `$FORCE` global to force the procedure regardless.
+  #
+  class Tool < BasicTool
+    include ShellUtils
+  end
+
 end
+
+require_relative 'detroit/assembly'
+#require_relative 'detroit/standard'
+

data/lib/detroit.yml

@@ -1,44 +1,59 @@
 ---
-source:
-- PROFILE
-- meta
+revision: 2013
+type: ruby
+sources:
+- var
 authors:
 - name: Trans
   email: transfire@gmail.com
-copyrights:
-- holder: Thomas Sawyer
-  year: '2007'
-  license: GPL3
+organizations: []
 requirements:
 - name: facets
-- name: pom
-- name: qed
-  groups:
+- name: indexer
+- groups:
   - test
   development: true
-dependencies: []
-alternatives: []
+  name: qed
+- groups:
+  - build
+  development: true
+  name: detroit-yard
+- groups:
+  - build
+  development: true
+  name: detroit-gem
 conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/detroit
+  label: Homepage
+- type: code
+  uri: http://github.com/rubyworks/detroit
+  label: Source Code
+- type: mail
+  uri: http://groups.google.com/rubyworks-mailinglist
+  label: Mailing List
 repositories:
-- uri: http://github.com/proutils/detroit.git
+- name: upstream
   scm: git
-  name: upstream
-resources:
-  home: http://rubyworks.github.com/detroit
-  code: http://github.com/rubyworks/detroit
-  mail: http://groups.google.com/rubyworks-mailinglist
-extra: {}
-load_path:
-- lib
-revision: 0
-created: '2007-10-10'
-summary: Software Production Mangement
-title: Detroit
-version: 0.3.0
+  uri: http://github.com/proutils/detroit.git
+categories: []
+copyrights:
+- holder: Rubyworks
+  year: '2007'
+  license: GPL-3.0
+customs: []
+paths:
+  lib:
+  - lib
 name: detroit
-suite: detroit
+title: Detroit
+summary: Software Production Mangement
+created: '2007-10-10'
 description: Detroit is an advanced lifecycle build system. With Detroit, build tasks
   are user defined service instances tied to stops along a track. Whenever the detroit
   console command is run, a track is followed from beginning to designated destination.
-organization: rubyworks
-date: '2012-04-01'
+suite: detroit
+version: 0.4.0
+date: '2014-01-13'

data/lib/detroit/assembly.rb

@@ -1,219 +1,75 @@
 module Detroit
 
-  # Assembly encapsulates a `Assembly` file and it's service instance
-  # configurations.
-  class Assembly
-
-    # Load Scedule file.
-    def self.load(input)
-      new(input)
-    end
-
-    # Hash table of services.
-    attr :services
-
-    private
-
-    # Initialize new Assembly instance.
-    def initialize(file, options={})
-      @project = options[:project]
-
-      @services = {}
+  # Define an assembly.
+  #
+  # @return nothing.
+  def self.assembly(name, &block)
+    ass = Assembly.new(name, &block)
+    const_set(name, ass)
+  end
 
-      @file = (String === file ? File.new(file) : file)
+  # Map of toolchain names to classes.
+  #
+  # @return [Hash<Symbol,Class>] All defined assemblies.
+  def self.assemblies
+    @assemblies ||= {}
+  end
 
-      case File.extname(@file.path)
-      when '.rb'
-        instance_eval(@file.read, @file.path)
-      when '.yml', '.yaml'
-        @services = YAML.load(erb(@file.read))
-      else
-        text = @file.read
-        if /^---/ =~ text
-          @services = YAML.load(erb(text))
-        else
-          instance_eval(text, @file.path)
-        end
-      end
-    end
+  ##
+  # An *assembly* is a set of production lines where each line is a list
+  # of named work stations.
+  #
+  class Assembly < Module
 
-    # Define a service.
-    def service(name, settings={}, &block)
-      if block
-        block_context = BlockContext.new(&block)
-        settings.update(block_context.settings)
-      end
-      @services[name.to_s] = settings.rekey(&:to_s)
-    end
+    def initialize(name, &block)
+      Detroit.assemblies[name.to_s.downcase.to_sym] = self
 
-    alias_method :tool, :service
+      @lines = []
+      @tools = []
 
-    #
-    #
-    #
-    #
-    def custom(name, &block)
-      context  = CustomContext.new(&block)
-      settings = context.settings
-      @services[name.to_s] = settings.rekey(&:to_s)
+      super(&block) #module_eval(&block)
     end
 
-    # Access to project data.
-    #
-    # NOTE: Thinking that the project should be relative
-    # to the Routine file itself, unless a `project` is passed
-    # in manually through the initializer. In the mean time,
-    # the project is just relative to the current working directory.
+    # Returns a list of lists of stops.
     #
-    # TODO: Make configurable and use .ruby by default ?
-    def project
-      @project ||= POM::Project.find #(file_directory)
-    end
-
-    # Capitalized service names called as methods
-    # can also define a service.
-    def method_missing(sym, *args, &block)
-      service_class = sym.to_s
-      case service_class
-      when /^[A-Z]/
-        if Hash === args.last
-          args.last[:service] = service_class
-        else
-          args << {:service=>service_class}
-        end
-        case args.first
-        when String, Symbol
-          name = args.first
-        else
-          name = service_class.to_s.downcase
-        end
-        service(name, *args, &block)
-      else
-        super(sym, *args, &block)
-      end
+    # @return [Array<Array<Symbol>>] lines.
+    def lines
+      @lines
     end
 
-    private
-
-    # Process Routine document via ERB.
-    def erb(text)
-      context = ERBContext.new(project)
-      ERB.new(text).result(context.__binding__)
+    # Define a chain of named links.
+    def line(*stations)
+      # TODO: raise error if stage already used ?
+      self.lines << stations.map{ |s| s.to_sym }
     end
 
-    # ERBContext provides the clean context to process a Routine
-    # as an ERB template.
-    class ERBContext
-      #
-      def initialize(project)
-        @project = project
-      end
-
-      # Access to a clean binding.
-      def __binding__
-        binding
-      end
-
-      # Provide access to project data.
-      def project
-        @project
-      end
+    # Lookup a chain by a given stage name.
+    #
+    # @return nothing.
+    def find(station)
+      station = station.to_sym
 
-      #
-      def method_missing(name, *args)
-        if project.respond_to?(name)
-          project.__send__(name, *args)
-        elsif project.metadata.respond_to?(name)
-          project.metadata.__send__(name, *args)
-        else
-          super(name, *args)
-        end
+      lines.find do |line|
+        line.include?(station)
       end
     end
 
+    # Add tool to toolchain.
     #
-    class BlockContext
-      #
-      attr :settings
-
-      #
-      def initialize(&b)
-        @settings = {}
-        b.arity == 1 ? b.call(self) : instance_eval(&b)
-      end
-
-      #
-      def set(name, value=nil, &block)
-        if block
-          block_context = BlockContext.new
-          block.call(block_context)
-          @settings[name.to_s] = block_context.settings
-        else
-          @settings[name.to_s] = value
-        end
-      end
-
-      #
-      def method_missing(symbol, value=nil, *args)
-        case name = symbol.to_s
-        when /=$/
-          @settings[name.chomp('=')] = value
-        else
-          super(symbol, value=nil, *args)
-        end
-      end
+    # @return [Class] The tool class.
+    def register_tool(tool_class)
+      tool_class.assembly = self
+      @tools << tool_class
+      Detroit.register_tool(tool_class)
     end
 
+    # When the tool chain is included into a class, register
+    # that class as a tool.
     #
-    class CustomContext
-      #
-      attr :settings
-      #
-      def initialize(&b)
-        @settings = {}
-        b.arity == 0 ? instance_eval(&b) : b.call(self)
-      end
-      #
-      def method_missing(s,a=nil,*x,&b)
-        case s.to_s
-        when /=$/
-          @settings[s.to_s.chomp('=').to_sym] = b ? b : a
-        else
-          return @settings[s] unless a
-          @settings[s] = b ? b : a
-        end
-      end
-      def respond_to?(s)
-        @settings.key?(s.to_sym)
-      end
+    # @return [void] The tool class.
+    def included(tool_class)
+      register_tool(tool_class) unless @tools.include?(tool_class)
     end
-
   end
 
-  # NOTE: This is problematic, because a Scheudle file should really know from
-  # what file it was derived.
-
-  #
-  DOMAIN = "rubyworks.github.com/detroit,2011-05-27"
-
-  # TODO: If using Psych rather than Syck, then define a domain type.
-
-  #if defined?(Psych) #RUBY_VERSION >= '1.9'
-  #  YAML::add_domain_type(DOMAIN, "assembly") do |type, hash|
-  #    Assembly.load(hash)
-  #  end
-  #else
-    YAML::add_builtin_type("assembly") do |type, value|
-      value
-      #case value
-      #when String
-      #  Assembly.eval(value)
-      #when Hash
-      #  Assembly.new(value)
-      #else
-      #  raise "ERROR: Invalid Assembly"
-      #end
-    end
-  #end
-
 end