class Slim::Embedded

def create(name, options)
  constructor = engines[name] || raise(Temple::FilterError, "Embedded engine #{name} not found")
  constructor.call(options)
end

def enabled?(name)
  (!@enabled || @enabled.include?(name)) &&
    (!@disabled || !@disabled.include?(name))
end

def initialize(opts = {})
  super
  @engines = {}
  @enabled = normalize_engine_list(options[:enable_engines])
  @disabled = normalize_engine_list(options[:disable_engines])
end

def normalize_engine_list(list)
  raise(ArgumentError, "Option :enable_engines/:disable_engines must be String or Symbol list") unless !list || Array === list
  list && list.map(&:to_sym)
end

def on_slim_embedded(name, body, attrs)
  name = name.to_sym
  raise(Temple::FilterError, "Embedded engine #{name} is disabled") unless enabled?(name)
  @engines[name] ||= self.class.create(name, options)
  @engines[name].on_slim_embedded(name, body, attrs)
end

def register(name, klass, *option_filter)
  name = name.to_sym
  local_options = option_filter.last.respond_to?(:to_hash) ? option_filter.pop.to_hash : {}
  define_options(name, *option_filter)
  klass.define_options(name)
  engines[name.to_sym] = proc do |options|
    klass.new({}.update(options).delete_if {|k,v| !option_filter.include?(k) && k != name }.update(local_options))
  end
end