detroit 0.1.0 → 0.2.0

data/lib/detroit/assembly.rb

@@ -1,80 +1,219 @@
 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
+  # Assembly encapsulates a `Assembly` file and it's service instance
+  # configurations.
+  class Assembly
 
-  # Define a new assembly.
-  def self.assembly(name, &block)
-    assemblies[name.to_sym] = Assembly.new(name, &block)
-  end
+    # Load Scedule file.
+    def self.load(input)
+      new(input)
+    end
 
-  # The Assembly class encapsulates an *assembly system* which consists of
-  # a set of interrelated assembly lines, or tracks.
-  class Assembly
+    # Hash table of services.
+    attr :services
 
-    # Name of the assembly system.
-    attr :name
+    private
 
-    # Returns a Hash of track names mapped to list of stops.
-    attr :lines
+    # Initialize new Assembly instance.
+    def initialize(file, options={})
+      @project = options[:project]
 
-    # Lines are also called `tracks`.
-    alias_method :tracks, :lines
+      @services = {}
 
-    # Create a new instance.
-    def initialize(name, &block)
-      @name   = name.to_sym
-      @lines  = {:maintenance => MAINTENANCE_TRACK}
-      instance_eval(&block) if block
-    end
+      @file = (String === file ? File.new(file) : file)
 
-    # Define an assembly line.
-    def line(name, *stops)
-      if stops.empty?
-        @lines[name.to_sym]
+      case File.extname(@file.path)
+      when '.rb'
+        instance_eval(@file.read, @file.path)
+      when '.yml', '.yaml'
+        @services = YAML.load(erb(@file.read))
       else
-        @lines[name.to_sym] = stops.map{ |s| s.to_sym }
+        text = @file.read
+        if /^---/ =~ text
+          @services = YAML.load(erb(text))
+        else
+          instance_eval(text, @file.path)
+        end
       end
     end
 
-    # Lines are also called tracks.
-    alias_method :track, :line
+    # 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
 
-    # 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.
+    alias_method :tool, :service
+
+    #
     #
-    # 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
+    #
+    #
+    def custom(name, &block)
+      context  = CustomContext.new(&block)
+      settings = context.settings
+      @services[name.to_s] = settings.rekey(&:to_s)
+    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.
+    #
+    # 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
-          track = tracks[name]
-            raise "Unknown track `#{name}'." unless track
-          unless track.include?(stop)
-            raise "Unknown stop `#{stop}` for track `#{name}'."
-          end
+          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
-        track = tracks[name]
+        super(sym, *args, &block)
       end
-      track
     end
 
-    # Did I mention that `line` and `track` are synonyms?
-    alias_method :get_line, :get_track
+    private
+
+    # Process Routine document via ERB.
+    def erb(text)
+      context = ERBContext.new(project)
+      ERB.new(text).result(context.__binding__)
+    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
+
+      #
+      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
+      end
+    end
+
+    #
+    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
+    end
+
+    #
+    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
+    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

data/lib/detroit/assembly_system.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.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

@@ -8,18 +8,18 @@ module Detroit
     # Configuration directory name (most likely a hidden "dot" directory).
     DIRECTORY = "detroit"
 
-    # File identifier used to find a project's Schedule(s).
-    FILE_EXTENSION = "schedule"
+    # 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 routine files.
+    # The list of a project's assembly files.
     #
     # @return [Array<String>] routine files
-    attr :schedules
+    attr :assemblies
 
-    # Service configurations from Schedule or *.schedule files.
+    # Service configurations from Assembly or *.assembly files.
     # 
     # @return [Hash] service settings
     attr :services
@@ -32,22 +32,22 @@ module Detroit
     attr :defaults
 
     #
-    def initialize(schedule_files=nil)
-      if schedule_files && !schedule_files.empty?
-        @schedule_filenames = schedule_files
+    def initialize(assembly_files=nil)
+      if assembly_files && !assembly_files.empty?
+        @assembly_filenames = assembly_files
       else
-        @schedule_filenames = nil
+        @assembly_filenames = nil
       end
 
-      @schedules = {}
-      @services  = {}
-      @defaults  = {}
+      @assemblies = {}
+      @services   = {}
+      @defaults   = {}
 
       @loaded_plugins = {}
 
       load_plugins
       load_defaults
-      load_schedules
+      load_assemblies
     end
 
     #--
@@ -60,8 +60,14 @@ module Detroit
     # Load a plugin.
     def load_plugin(name)
       @loaded_plugins[name] ||= (
-        require "detroit-#{name}"
-        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
 
@@ -84,16 +90,16 @@ module Detroit
     end
 
     #
-    def load_schedules
-      schedule_filenames.each do |file|
-        load_schedule_file(file)
+    def load_assemblies
+      assembly_filenames.each do |file|
+        load_assembly_file(file)
       end
     end
 
     #
-    def load_schedule_file(file)
-      @schedules[file] = Schedule.load(File.new(file))
-      @services.merge!(schedules[file].services)
+    def load_assembly_file(file)
+      @assemblies[file] = Assembly.load(File.new(file))
+      @services.merge!(assemblies[file].services)
     end
 
     # Set defaults.
@@ -101,21 +107,21 @@ module Detroit
       @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
+    # 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 schedule_filenames
-      @schedule_filenames ||= (
+    def assembly_filenames
+      @assembly_filenames ||= (
         files = []
-        ## match 'Schedule' or '.schedule' file
+        ## 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/*.schedule' or 'detroit/*.schedule'
+          ## match '.detroit/*.assembly' or 'detroit/*.assembly'
           files += project.root.glob("{,.}#{DIRECTORY}/*.#{FILE_EXTENSION}", :casefold)
-          ## match 'task/*.schedule' (OLD SCHOOL)
+          ## match 'task/*.assembly' (OLD SCHOOL)
           files += project.root.glob("{task,tasks}/*.#{FILE_EXTENSION}", :casefold)
           ## only files
           files = files.select{ |f| File.file?(f) }
@@ -140,7 +146,7 @@ module Detroit
     def load_detroit_file(file)
       #@dir = File.dirname(file)
 
-      schedules[file] = 
+      assemblies[file] = 
 
       # TODO: can we just read the first line of the file and go from there?
       #text = File.read(file).strip