module Detroit

Public Class Methods

assemblies() click to toggle source

Map of toolchain names to classes.

@return [Hash<Symbol,Class>] All defined assemblies.

# File lib/detroit/assembly.rb, line 14
def self.assemblies
  @assemblies ||= {}
end
assembly(name, &block) click to toggle source

Define an assembly.

@return nothing.

# File lib/detroit/assembly.rb, line 6
def self.assembly(name, &block)
  ass = Assembly.new(name, &block)
  const_set(name, ass)
end
const_missing(name) click to toggle source

Access to project metadata via constants.

Calls superclass method
# File lib/detroit.rb, line 11
def self.const_missing(name)
  metadata[name.to_s.downcase] || super(name)
end
define_tool_method(name, tool_class) click to toggle source

Define tool method.

# File lib/detroit.rb, line 56
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
metadata() click to toggle source

Access to this project’s metadata.

# File lib/detroit.rb, line 3
def self.metadata
  @metadata ||= (
    require 'yaml'
    YAML.load(File.new(File.dirname(__FILE__) + '/detroit.yml'))
  )
end
project(root) click to toggle source
# File lib/detroit/project.rb, line 5
def self.project(root)
  Project.factory(root)
end
register_tool(tool_class) click to toggle source

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.

# File lib/detroit.rb, line 69
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
tool_exec(*argv) click to toggle source

Execute a sepcific detroit tool.

Note this uses the executable gem to automatically “cli-ify” a tool class.

# File lib/detroit/exec.rb, line 8
def self.tool_exec(*argv)
  require 'executable'

  tool, stop = argv.shift.split(':')     

  raise "No tool specified." unless tool
  raise "No tool stop specified." unless stop

  begin
    require "detroit-#{tool}"
  rescue LoadError
    raise "Unknown tool. Perhaps try `gem install detroit-#{tool}`."
  end

  tool_class = Detroit.tools[tool]

  exec_class = Class.new(tool_class) do
    include Executable

    # TODO: Fix executable, to at least super if defined super.
    define_method(:initialize) do
      tool_class.instance_method(:initialize).bind(self).call
    end

    # Show this message.
    def help!
      cli.show_help
      exit
    end
    alias :h! :help!

    define_method(:call) do |*args|
      if assemble?(stop.to_sym)
        assemble(stop.to_sym)
      else
        raise "#{tool} does not know how to #{stop}."
      end
    end
  end

  #exec_class.send(:define_method, :command_name) do
  #  tool
  #end

  exec_class.run(argv)
end
tools() click to toggle source

Tool registry.

# File lib/detroit.rb, line 49
def self.tools
  @tools ||= {}
end

Public Instance Methods

help!() click to toggle source

Show this message.

# File lib/detroit/exec.rb, line 33
def help!
  cli.show_help
  exit
end