detroit 0.1.0

data/lib/detroit/custom.rb

@@ -0,0 +1,65 @@
+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
+
+    private
+
+    # 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 stop == 'service'
+        next if stop == 'tracks' or stop == 'track'
+        next if stop == 'active'
+        next if stop == 'priority'
+        # remaining options are names of track stops
+        #tracks.each do |t|
+          src = %{
+            def #{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)
+      super(s, *a, &b) if @context.respond_to?(s)
+    end
+
+  end
+
+end

data/lib/detroit/dsl.rb

@@ -0,0 +1,55 @@
+module Detroit
+
+  # NOT YET IN USE.
+  module DSL
+
+    # Define a track.
+    #
+    # Examples
+    #
+    #   track :site do
+    #     route :maintainence do
+    #       stops :reset, :clean, :purge
+    #     end
+    #   end
+    #
+    def track(&block)
+      Track.new(&block)
+    end
+
+    # Define a service.
+    #
+    # Examples
+    #
+    #   service :foo do
+    #     reset do
+    #       utime(0,0, project.path(:log) + 'foo.log')
+    #     end
+    #   end
+    #
+    def service(name, &block)
+      Service.registry[name.to_s] ||= ServiceDSL.new(&block).service_class
+    end
+
+    # ServiceDSL is used to define services via the Detroit DSL.
+    class ServiceDSL < BasicObject
+      attr :service_class
+
+      def initialize(name, &block)
+        @service_class = Class.new(Detroit::Service)
+      end
+
+      def available(&block)
+        (class << @service_class; self; end).class_eval do
+          define_method(:available?, &block)
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        @service_class.define_method(name, &block)
+      end
+    end
+
+  end
+
+end

data/lib/detroit/schedule.rb

@@ -0,0 +1,187 @@
+module Detroit
+
+  # Schedule encapsulates a `Schedule` file and it's service instance
+  # configurations.
+  class Schedule
+
+    # Load Scedule file.
+    def self.load(input)
+      new(input)
+    end
+
+    # Hash table of services.
+    attr :services
+
+    private
+
+    # Initialize new Schedule instance.
+    def initialize(file, options={})
+      @project = options[:project]
+
+      @services = {}
+
+      @file = (String === file ? File.new(file) : file)
+
+      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
+
+    # Define a service.
+    def service(name, settings={}, &block)
+      if block
+        block_context = BlockContext.new(&block)
+        settings = block_context.settings
+      end
+      @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
+          args << {:services=>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
+    end
+
+    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(&block)
+        @settings = {}
+        if block.arity == 0
+          instance_eval(&block)
+        else
+          block.call(self)
+        end
+      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
+
+  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, "schedule") do |type, hash|
+  #    Schedule.load(hash)
+  #  end
+  #else
+    YAML::add_builtin_type("schedule") do |type, value|
+      value
+      #case value
+      #when String
+      #  Schedule.eval(value)
+      #when Hash
+      #  Schedule.new(value)
+      #else
+      #  raise "ERROR: Invalid Schedule"
+      #end
+    end
+  #end
+
+end

data/lib/detroit/service.rb

@@ -0,0 +1,188 @@
+module Detroit
+
+  #
+  #def self.services
+  #  @registry ||= {}
+  #end
+ 
+  # Service class wraps a Tool instance.
+  #
+  # TODO: change name ?
+  #
+  # TODO: Need to work on how to limit a service's tracks per-assembly.
+  class ServiceWrapper
+    attr :key
+    attr :tracks
+    attr :priority
+    attr :active
+    attr :service
+    #attr :options
+
+    # Set the priority. Priority determines the order which
+    # services on the same stop are run.
+    def priority=(integer)
+      @priority = integer.to_i
+    end
+
+    # Set the tracks a service will be available on.
+    def tracks=(list)
+      @tracks = list.to_list
+    end
+
+    #
+    def active=(boolean)
+      @active = !!boolean
+    end
+
+    # Create new ServiceWrapper.
+    def initialize(key, service_class, options)
+      @key      = key
+
+      ## set service defaults
+      @tracks   = nil #service_class.tracks
+      @priority = 0
+      @active   = true
+
+      self.active   = options.delete('active')   if !options['active'].nil?
+      self.tracks   = options.delete('tracks')   if options.key?('tracks')
+      self.priority = options.delete('priority') if options.key?('priority')
+
+      @service = service_class.new(options)
+    end
+
+    # Does the service support the given stop.
+    def stop?(name)
+      @service.respond_to?(name)
+    end
+
+    # Run the service stop procedure.
+    def invoke(name)
+      @service.__send__(name)  # public_send
+    end
+
+    #
+    def inspect
+      "<#{self.class}:#{object_id} @key='#{key}'>"
+    end
+  end
+
+end
+
+
+
+=begin
+  # Mixin module is added to Service and Tool.
+  module Serviceable
+
+    #
+    def self.included(base)
+      base.extend ClassRegistry
+      base.extend DomainLanguage
+    end
+
+    # Register new instance of the Service class.
+    module ClassRegistry
+
+      # Class-level attribute of registered Service subclasses.
+      # 
+      # Returns a Hash.
+      def registry
+        Detroit.services
+      end
+
+      # TODO: Probably should make a named registry instead.
+      def inherited(base)
+        return if base.name.to_s.empty?
+        if base.name !~ /Service$/
+          registry[base.basename.downcase] = base
+        end
+      end
+
+      # Returns a Class which is a new subclass of the current class.
+      def factory(&block)
+        Class.new(self, &block)
+      end
+
+      #
+      def 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
+
+    end
+
+    # Service Domain language. This module extends the Service class,
+    # to provide a convenience interface for defining stops.
+    module DomainLanguage
+      ## TODO: Err.. Is this being used?
+      #def init(&block)
+      #  define_method(:init, &block)
+      #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.
+      def tracks
+      end
+
+      # TODO: Perhaps deprecate this in favor of just defining an `availabe?`
+      # class method.
+      def available(&block)
+        @available = block if block
+        @available ||= nil
+      end
+
+      #
+      def available?(project)
+        return true unless available
+        @available.call(project)
+      end
+    end
+
+    #attr_reader :service_name
+
+    #
+    def service_title
+      self.class.name
+    end
+
+    # TODO: Is this being used?
+    #def service_actions
+    #  self.class.service_actions
+    #end
+
+    #
+    #def inspect
+    #  "<#{self.class}:#{object_id}>"
+    #end
+  end
+
+  # The Service class is the base class for defining basic or delgated services.
+  class Service
+    include Serviceable
+
+    #
+    attr :options
+
+    def initialize(options={})
+      @options = options
+    end
+  end
+
+
+end #module Detroit
+
+# Provides a clean namespace for creating services.
+module Detroit::Plugins
+  Service = Detroit::Service
+  Tool    = Detroit::Tool
+end
+
+=end
+
+# TOPLEVEL DSL?
+#def service(name, &block)
+#  #Detroit.services[name] = Service.factory(&block)
+#  Detroit::Service.registry[name.to_s] = Detroit::Service.factory(&block)
+#end