detroit 0.1.0

data/lib/detroit/assembly.rb

@@ -0,0 +1,80 @@
+module Detroit
+
+  # All assemblies and tracks have a maintenance sub-track.
+  # For this reason stop names `reset`, `clean` and `purge`
+  # are reserved names and MUST not be used as stop names
+  # in defining custom lines.
+  MAINTENANCE_TRACK = [:reset, :clean, :purge]
+
+  # Returns Hash of name and Circuit instance pairs.
+  def self.assemblies
+    @assemblies ||= {}
+  end
+
+  # Define a new assembly.
+  def self.assembly(name, &block)
+    assemblies[name.to_sym] = Assembly.new(name, &block)
+  end
+
+  # The Assembly class encapsulates an *assembly system* which consists of
+  # a set of interrelated assembly lines, or tracks.
+  class Assembly
+
+    # Name of the assembly system.
+    attr :name
+
+    # Returns a Hash of track names mapped to list of stops.
+    attr :lines
+
+    # Lines are also called `tracks`.
+    alias_method :tracks, :lines
+
+    # Create a new instance.
+    def initialize(name, &block)
+      @name   = name.to_sym
+      @lines  = {:maintenance => MAINTENANCE_TRACK}
+      instance_eval(&block) if block
+    end
+
+    # Define an assembly line.
+    def line(name, *stops)
+      if stops.empty?
+        @lines[name.to_sym]
+      else
+        @lines[name.to_sym] = stops.map{ |s| s.to_sym }
+      end
+    end
+
+    # Lines are also called tracks.
+    alias_method :track, :line
+
+    # Lookup track by name and (optional) stop. If the stop belongs
+    # to the maintenance sub-track then the maintenance sub-track will
+    # be returned instead of the track itself.
+    #
+    # The Application class uses this to simplify track lookup.
+    def get_track(name, stop=nil)
+      name = name.to_sym
+      if stop
+        stop = stop.to_sym
+        if MAINTENANCE_TRACK.include?(stop.to_sym)
+          track = MAINTENANCE_TRACK
+        else
+          track = tracks[name]
+            raise "Unknown track `#{name}'." unless track
+          unless track.include?(stop)
+            raise "Unknown stop `#{stop}` for track `#{name}'."
+          end
+        end
+      else
+        track = tracks[name]
+      end
+      track
+    end
+
+    # Did I mention that `line` and `track` are synonyms?
+    alias_method :get_line, :get_track
+
+  end
+
+end

data/lib/detroit/config.rb

@@ -0,0 +1,197 @@
+module Detroit
+
+  # Detroit configuration. Configuration comes from a main +Routine+
+  # and/or +.routine+ files.
+  class Config
+    #instance_methods.each{ |m| private m unless /^__/ =~ m.to_s }
+
+    # Configuration directory name (most likely a hidden "dot" directory).
+    DIRECTORY = "detroit"
+
+    # File identifier used to find a project's Schedule(s).
+    FILE_EXTENSION = "schedule"
+
+    # Current POM::Project object.
+    #attr :project
+
+    # The list of a project's routine files.
+    #
+    # @return [Array<String>] routine files
+    attr :schedules
+
+    # Service configurations from Schedule or *.schedule files.
+    # 
+    # @return [Hash] service settings
+    attr :services
+
+    # Service defaults. This is a mapping of service names to
+    # default settings. Very useful for when using the same
+    # service more than once.
+    #
+    # @return [Hash] default settings
+    attr :defaults
+
+    #
+    def initialize(schedule_files=nil)
+      if schedule_files && !schedule_files.empty?
+        @schedule_filenames = schedule_files
+      else
+        @schedule_filenames = nil
+      end
+
+      @schedules = {}
+      @services  = {}
+      @defaults  = {}
+
+      @loaded_plugins = {}
+
+      load_plugins
+      load_defaults
+      load_schedules
+    end
+
+    #--
+    # TODO: Use this, or pass in via initialize?
+    #++
+    def project
+      Detroit.project
+    end
+
+    # Load a plugin.
+    def load_plugin(name)
+      @loaded_plugins[name] ||= (
+        require "detroit-#{name}"
+        name
+      )
+    end
+
+    # Pre-load plugins using `.detroit/plugins.rb`.
+    def load_plugins
+      if file = project.root.glob('{.,}#{DIRECTORY}/plugins{,.rb}').first
+        require file
+      else
+        self.defaults = {}
+      end
+    end
+
+    # Load defaults from `.detroit/defaults.yml`.
+    def load_defaults
+      if file = project.root.glob('{.,}#{DIRECTORY}/defaults{,.yml,.yaml}').first
+        self.defaults = YAML.load(File.new(file))
+      else
+        self.defaults = {}
+      end
+    end
+
+    #
+    def load_schedules
+      schedule_filenames.each do |file|
+        load_schedule_file(file)
+      end
+    end
+
+    #
+    def load_schedule_file(file)
+      @schedules[file] = Schedule.load(File.new(file))
+      @services.merge!(schedules[file].services)
+    end
+
+    # Set defaults.
+    def defaults=(hash)
+      @defaults = hash.to_h
+    end
+
+    # If a `Schedule` or `.schedule` file exists, then it is returned. Otherwise
+    # all `*.schedule` files are loaded. To load `*.schedule` files from another
+    # directory add the directory to config options file.
+    def schedule_filenames
+      @schedule_filenames ||= (
+        files = []
+        ## match 'Schedule' or '.schedule' file
+        files = project.root.glob("{,.,*.}#{FILE_EXTENSION}{,.rb,.yml,.yaml}", :casefold)
+        ## only files
+        files = files.select{ |f| File.file?(f) }
+        ## 
+        if files.empty?
+          ## match '.detroit/*.schedule' or 'detroit/*.schedule'
+          files += project.root.glob("{,.}#{DIRECTORY}/*.#{FILE_EXTENSION}", :casefold)
+          ## match 'task/*.schedule' (OLD SCHOOL)
+          files += project.root.glob("{task,tasks}/*.#{FILE_EXTENSION}", :casefold)
+          ## only files
+          files = files.select{ |f| File.file?(f) }
+        end
+        files
+      )
+    end
+
+    #
+    def each(&block)
+      services.each(&block)
+    end
+
+    #
+    def size
+      services.size
+    end
+
+=begin
+    # If using a `Routine` file and want to import antoher file then use
+    # `import:` entry.
+    def load_detroit_file(file)
+      #@dir = File.dirname(file)
+
+      schedules[file] = 
+
+      # TODO: can we just read the first line of the file and go from there?
+      #text = File.read(file).strip
+
+      ## if yaml vs. ruby file
+      #if (/\A---/ =~ text || /\.(yml|yaml)$/ =~ File.extname(file))
+      #  #data = parse_detroit_file_yaml(text, file)
+      #  YAML.load(text)
+      #else
+      #  data = parse_detroit_file_ruby(text, file)
+      #end    
+
+      ## extract defaults
+      #if defaults = data.delete('defaults')
+      #  @defaults.merge!(defaults)
+      #end
+
+      ## import other files
+      #if import = data.delete('import')
+      #  [import].flatten.each do |glob|
+      #    routine(glob)
+      #  end
+      #end
+
+      ## require plugins
+      #if plugins = data.delete('plugins')
+      #  [plugins].flatten.each do |file|
+      #    require file
+      #  end
+      #end
+
+      #@services.update(data)
+    end
+=end
+
+    ## Parse a YAML-based routine.
+    #def parse_detroit_file_yaml(text, file)
+    #  YAMLParser.parse(self, text, file)
+    #end
+
+    ## Parse a Ruby-based routine.
+    #def parse_detroit_file_ruby(text, file)
+    #  RubyParser.parse(self, text, file)
+    #end
+
+    ## TODO: Should the +dir+ be relative to the file or project.root?
+    #def routine(glob)
+    #  pattern = File.join(@dir, glob)
+    #  Dir[pattern].each{ |f| load_detroit_file(f) }
+    #end
+
+  end
+
+end

data/lib/detroit/control.rb

@@ -0,0 +1,124 @@
+module Detroit
+
+  # The control module is a function module that extends
+  # the toplevel Detroit namespace module.
+  module Control
+
+    # Location of standard plugins.
+    #PLUGIN_DIRECTORY = File.dirname(__FILE__) + '/plugins'
+
+    # Returns Array of standard plugin file names.
+    #def standard_plugins
+    #  Dir[PLUGIN_DIRECTORY + '/*.rb']
+    #end
+
+    # Universal acccess to the current project.
+    #
+    # TODO: Is Control#project being used?
+    def project
+      @project ||= POM::Project.find
+    end
+
+    # Returns Application given options.
+    def application(options={})
+      Application.new(options)
+    end
+
+    # Run the command line interface.
+    def cli(*argv)
+      cli_options = {
+        :schedules => [],
+        :trace=>nil, :trial=>nil, :debug=>nil, :quiet=>nil, :verbose=>nil,
+        :force=>nil, :multitask=>nil, :skip=>[]
+      }
+
+      cli_usage(cli_options).parse!(argv)
+
+      #if /\.schedule$/ =~ argv[0]
+      #  job = argv[1]
+      #  begin
+      #    application(cli_options).runscript(argv[0], job)
+      #  rescue => error
+      #    $stderr.puts error.message
+      #    exit -1
+      #  end
+      #else
+        begin
+          application(cli_options).start(*argv)
+        rescue => error
+          if $DEBUG
+            raise error
+          else
+            $stderr.puts error.message
+            exit -1
+          end
+        end
+      #end
+    end
+
+    # Returns an instance of OptionParser.
+    def cli_usage(options)
+      @usage ||= (
+        OptionParser.new do |usage|
+          usage.banner = "Usage: detroit [<track>:]<stop> [options]"
+          usage.on('-m', '--multitask', "Run work elements in parallel.") do
+            options[:multitask] = true
+          end
+          usage.on('-S', '--skip [SERVICE]', 'Skip a service.') do |skip|
+            options[:skip] << skip
+          end
+
+          usage.on('-a', '--assembly=NAME', "Select assembly. Default is `standard'.") do |assembly|
+            options[:assembly] = assembly
+          end
+          usage.on('-s', '--schedule [FILE]', 'Use specific schedule file(s).') do |file|
+            options[:schedules] << file
+          end
+
+          usage.on('-F', '--force', "Force operations.") do
+            options[:force] = true
+          end
+          usage.on('--trace', "Run in TRACE mode.") do
+            #$TRACE = true
+            options[:trace] = true
+          end
+          usage.on('--trial', "Run in TRIAL mode (no disk writes).") do
+            #$TRIAL = true
+            options[:trial] = true
+          end
+          # TODO: do we really need verbose?
+          usage.on('--verbose', "Provided extra output.") do
+            options[:verbose] = true
+          end
+          usage.on('-q', '--quiet', "Run silently.") do
+            options[:quiet] = true
+          end
+
+          usage.on('-I=PATH', "Add directory to $LOAD_PATH") do |dirs|
+            dirs.to_list.each do |dir|
+              $LOAD_PATH.unshift(dir)
+            end
+          end
+          usage.on('--debug', "Run with $DEBUG set to true.") do
+            $DEBUG   = true
+            options[:debug] = true  # DEPRECATE?
+          end
+          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
+            exit
+          end
+          usage.on_tail('--config', "Produce a configuration template.") do
+            puts application.config_template.to_yaml
+            exit
+          end
+        end
+      )
+    end
+
+  end
+
+  extend Control
+end

data/lib/detroit/core_ext.rb

@@ -0,0 +1,139 @@
+#__DIR__ = File.dirname(__FILE__)
+
+#Dir[File.join(__DIR__, 'core_ext', '*.rb')].each do |file|
+#  require file
+#end
+
+#require 'facets'
+require 'facets/to_hash'
+require 'facets/module/basename'
+require 'facets/module/alias_accessor'
+require 'facets/pathname'
+#require 'facets/boolean'
+
+class Array
+
+  def to_list
+    self
+  end
+
+end
+
+class NilClass
+
+  def to_list
+    []
+  end
+
+end
+
+class String
+
+  # Helper method for cleaning list options.
+  # This will split the option on ':' or ';'
+  # if it is a string, rather than an array.
+  # And it will make sure there are no nil elements.
+
+  def to_list
+    split(/[:;,\n]/).map{ |s| s.strip }
+  end
+
+end
+
+# TODO: Replace these with facets/shellwords !!!
+
+# TODO: Belongs in Redtools, no?
+
+#
+class Array #:nodoc:
+
+  # Convert an array into commandline parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_console
+    #flags = (Hash===last ? pop : {})
+    #flags = flags.to_console
+    #flags + ' ' + join(" ")
+    to_argv.join(' ')
+  end
+
+  # TODO: DEPRECATE
+  alias_method :to_params, :to_console
+
+  #
+  def to_argv
+    flags = (Hash===last ? pop : {})
+    flags = flags.to_argv
+    flags + self
+  end
+
+#   def to_console
+#     flags = (Hash===last ? pop : {})
+#     flags = flags.collect do |f,v|
+#       m = f.to_s.size == 1 ? '-' : '--'
+#       case v
+#       when Array
+#         v.collect{ |e| "#{m}#{f} '#{e}'" }.join(' ')
+#       when true
+#         "#{m}#{f}"
+#       when false, nil
+#         ''
+#       else
+#         "#{m}#{f} '#{v}'"
+#       end
+#     end
+#     return (flags + self).join(" ")
+#   end
+
+end
+
+class Hash
+
+  # Convert a Hash into command line arguments.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+  def to_console
+    to_argv.join(' ')
+  end
+
+  # Convert a Hash into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+  def to_argv
+    flags = map do |f,v|
+      m = f.to_s.size == 1 ? '-' : '--'
+      case v
+      when Array
+        v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
+      when true
+        "#{m}#{f}"
+      when false, nil
+        ''
+      else
+        "#{m}#{f}='#{v}'"
+      end
+    end
+  end
+
+  # Turn a hash into arguments.
+  #
+  #   h = { :list => [1,2], :base => "HI" }
+  #   h.argumentize #=> [ [], { :list => [1,2], :base => "HI" } ]
+  #   h.argumentize(:list) #=> [ [1,2], { :base => "HI" } ]
+  #
+  def argumentize(args_field=nil)
+    config = dup
+    if args_field
+      args = [config.delete(args_field)].flatten.compact
+    else
+      args = []
+    end
+    args << config
+    return args
+  end
+
+  alias_method :command_vector, :argumentize
+
+end
+