detroit 0.3.0 → 0.4.0

data/lib/detroit/assembly_system.rb

@@ -1,80 +0,0 @@
-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.assembly_systems
-    @assembly_system ||= {}
-  end
-
-  # Define a new assembly system.
-  def self.assembly_system(name, &block)
-    assembly_systems[name.to_sym] = AssemblySystem.new(name, &block)
-  end
-
-  # The AssemblySystem class encapsulates  a set of interrelated
-  # assembly lines, or _tracks_.
-  class AssemblySystem
-
-    # 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

@@ -1,203 +0,0 @@
-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 Assembly(s).
-    FILE_EXTENSION = "assembly"
-
-    # Current POM::Project object.
-    #attr :project
-
-    # The list of a project's assembly files.
-    #
-    # @return [Array<String>] routine files
-    attr :assemblies
-
-    # Service configurations from Assembly or *.assembly 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(assembly_files=nil)
-      if assembly_files && !assembly_files.empty?
-        @assembly_filenames = assembly_files
-      else
-        @assembly_filenames = nil
-      end
-
-      @assemblies = {}
-      @services   = {}
-      @defaults   = {}
-
-      @loaded_plugins = {}
-
-      load_plugins
-      load_defaults
-      load_assemblies
-    end
-
-    #--
-    # TODO: Use this, or pass in via initialize?
-    #++
-    def project
-      Detroit.project
-    end
-
-    # Load a plugin.
-    def load_plugin(name)
-      @loaded_plugins[name] ||= (
-        begin
-          require "detroit-#{name}"
-        rescue LoadError => e
-          $stderr.puts "ERROR: #{e.message.capitalize}"
-          $stderr.puts "       Perhaps `gem install detroit-#{name}`?"
-          exit -1
-        end
-        name # true ?
-      )
-    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_assemblies
-      assembly_filenames.each do |file|
-        load_assembly_file(file)
-      end
-    end
-
-    #
-    def load_assembly_file(file)
-      @assemblies[file] = Assembly.load(File.new(file))
-      @services.merge!(assemblies[file].services)
-    end
-
-    # Set defaults.
-    def defaults=(hash)
-      @defaults = hash.to_h
-    end
-
-    # If a `Assembly` or `.assembly` file exists, then it is returned. Otherwise
-    # all `*.assembly` files are loaded. To load `*.assembly` files from another
-    # directory add the directory to config options file.
-    def assembly_filenames
-      @assembly_filenames ||= (
-        files = []
-        ## match 'Assembly' or '.assembly' 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/*.assembly' or 'detroit/*.assembly'
-          files += project.root.glob("{,.}#{DIRECTORY}/*.#{FILE_EXTENSION}", :casefold)
-          ## match 'task/*.assembly' (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)
-
-      assemblies[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

@@ -1,129 +0,0 @@
-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 = {
-        :system => nil, :assemblies => [], 
-        :trace=>nil, :trial=>nil, :debug=>nil, :quiet=>nil, :verbose=>nil,
-        :force=>nil, :multitask=>nil, :skip=>[]
-      }
-
-      usage = cli_usage(cli_options)
-      usage.parse!(argv)
-
-      #if /\.assembly$/ =~ 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('-s', '--system=NAME', "Select assembly system. Default is `standard'.") do |system|
-            options[:system] = system
-          end
-          usage.on('-a', '--assembly [FILE]', 'Use specific assembly file(s).') do |file|
-            options[:assemblies] << 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', "Provide 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 [TOOL]', "Display this help message.") do |tool|
-            if tool
-              application.display_help(tool)
-            else
-              puts usage
-            end
-            exit
-          end
-          usage.on_tail('-c', '--config TOOL', "Produce a configuration template.") do |tool|
-            puts application.config_template(tool).to_yaml
-            exit
-          end
-        end
-      )
-    end
-
-  end
-
-  extend Control
-end

data/lib/detroit/custom.rb

@@ -1,102 +0,0 @@
-module Detroit
-
-  # Custom tool is used to create "quicky" services.
-  #
-  # This is a useful alternative to writing a full-blown plugin
-  # when the need is simple.
-  #
-  class Custom < Tool
-
-    # Default track(s) in which this plugin operates.
-    DEFAULT_TRACK = "main"
-
-    # Which track(s) to run this custom plugin.
-    attr_accessor :track
-
-    # Special writer to allow single track or a list of tracks.
-    def track=(val)
-      @track = val.to_list #[val].flatten
-    end
-
-    # Plural alias for #track.
-    alias_accessor :tracks, :track
-
-    alias_accessor :on, :track
-
-    private
-
-    SPECIAL_OPTIONS = %w{
-      service track tracks on active priority project 
-      trial trace verbose force quiet
-    }
-
-    # Instantiate new custom plugin.
-    #
-    # FIXME: Custom#initialize seems to be running twice at startup. Why?
-    #
-    # This works by interpreting the service configuration as a hash of
-    # stop names to ruby code.
-    #
-    def initialize(options)
-      super(options)
-      options.each do |stop, script|
-        # skip specific names used for configuration
-        next if SPECIAL_OPTIONS.include? stop
-        # remaining options are names of track stops
-        #tracks.each do |t|
-          src = %{
-            def station_#{stop}
-              #{script}
-            end
-          }
-          (class << self; self; end).module_eval(src)
-        #end
-      end
-    end
-
-    # Set initial attribute defaults.
-    def initialize_defaults
-      @track = [DEFAULT_TRACK]
-    end
-
-    #
-    def method_missing(s, *a, &b)
-      if s.to_s.end_with?('=')
-      #  stop = s.to_s.chomp('=')
-      #  if !SPECIAL_OPTIONS.include?(stop)
-      #   (class << self; self; end).module_eval %{
-      #      def station_#{stop}
-      #        #{a.first}
-      #      end
-      #    }
-      #  end
-      else
-        if @context.respond_to?(s)
-          @context.__send__(s,*a,&b)
-        else
-          super(s, *a, &b)
-        end
-      end
-    end
-
-    # @todo should only respond to stop names and special options.
-    #def respond_to?(s)
-    #  return true if SPECIAL_OPTIONS.include?(s.to_s)
-    #  return true
-    #end
-
-    # RUBY 1.9
-    def respond_to_missing?(name, privy)
-      #return true if name.to_s.start_with?('station_')
-      return true if name.to_s.end_with?('=')
-      return true if @context.respond_to?(name)
-      false
-    end
-
-    def inspect
-      "#<Custom @on=#{track.join(',')}>"
-    end
-
-  end
-
-end