# File lib/ravn/bde/bolt.rb, line 178
def self::add_components( components )
        components.each do |type, opts|
                opts = opts.transform_keys( &:to_sym )
                self.log.debug "Finding and applying the %s component with options: %p" %
                        [ type, opts ]
                component = Ravn::BDE::Bolt::Component.find( type )
                opts = component.validate( opts )
                component.apply( self, **opts )
        rescue LoadError => err
                raise Ravn::BDE::InvalidBoltConfig, "Unknown component type \"%s\" (%s)" % [ type, err.message ]
        rescue Ravn::BDE::ValidationError => err
                raise Ravn::BDE::InvalidBoltConfig, err.message
        end
end

# File lib/ravn/bde/bolt.rb, line 225
def self::compile_message_handlers
        self.message_handler_map.each do |message_type_template, handler|
                message_type = self.expand_placeholders( message_type_template )
                self.log.debug "Installing a message handler: %s (%s): %p" %
                         [ message_type_template, message_type, handler ]
                self.register_message_handler( message_type, handler )
        end
end

# File lib/ravn/bde/bolt.rb, line 236
def self::expand_placeholders( string )
        return string.gsub( PLACEHOLDER_PATTERN ) do |_|
                name = $~[:placeholder]

                case name
                when 'bolt_id'
                        self.id.to_s
                when 'bolt_name'
                        (self.name || self.type).to_s
                when 'bolt_type'
                        self.type.to_s
                when 'bolt_text'
                        self.text.to_s
                when 'device_id'
                        Ravn.device_id
                else
                        raise "No expansion for `%s' in %p" % [ name, string ]
                end
        end
end

# File lib/ravn/bde/bolt.rb, line 123
def self::inherited( subclass )
        super

        subclass.instance_variable_set( :@message_handler_map, PHASE_METHODS.dup )
end

# File lib/ravn/bde/bolt.rb, line 282
def self::inspect
        string = super

        if self.id
                details = "%s%s Bolt {%s}" % [
                        self.type,
                        @name ? " - #@name" : '',
                        self.id
                ]
                string = string.sub( /Class/, details )
        end

        return string
end

# File lib/ravn/bde/bolt.rb, line 274
def self::is_draft?
        return @name ? true : false
end

# File lib/ravn/bde/bolt.rb, line 267
def self::is_relayed?
        return self.ontological_suffix ? true : false
end

# File lib/ravn/bde/bolt.rb, line 117
def self::name
        return @name || self.type
end

# File lib/ravn/bde/bolt.rb, line 303
def initialize
        self.log.debug "Creating an instance of %p" % [ self ]

        @id         = Ravn.uuid.generate
        @start_time = Ravn.monotonic_time
        @expires_at = nil
        @initiated  = false

        super()
end

# File lib/ravn/bde/bolt.rb, line 260
def self::path_name
        base = self.name || self.type
        return base.downcase.gsub( /\P{alnum}/, '_' )
end

# File lib/ravn/bde/bolt.rb, line 131
def self::segment_for_config( config )
        case config
        when String, Symbol
                config = 'Everyone' if config == :default
                segment_name = config.to_s
                segment = Ravn::BDE.segments[ segment_name ] or
                        raise Ravn::BDE::ValidationError, "no such segment %s" % [ config ]

                return segment
        when NilClass
                return Ravn::BDE::Segment.default
        else
                raise Ravn::BDE::ValidationError, "no such segment %p" % [ config ]
        end
end

# File lib/ravn/bde/bolt.rb, line 149
def self::tailor( id, type:, name: nil, text: "${bolt_name}", timeout: DEFAULT_TIMEOUT,
        to: nil, components: {}, **options )

        self.log.info "Tailoring '%s' bolt: %s (components: %p) with options: %p" %
                [ type, id, components, options ]

        subclass = Class.new( self )
        subclass.instance_variable_set( :@id, id )
        subclass.instance_variable_set( :@type, type )
        subclass.instance_variable_set( :@name, name )
        subclass.instance_variable_set( :@text, text )
        subclass.instance_variable_set( :@components, components )
        subclass.instance_variable_set( :@timeout, timeout )

        to = self.segment_for_config( to )
        subclass.instance_variable_set( :@to, to )

        subclass.instance_variable_set( :@ontological_suffix, options[:ontological_suffix] )

        yield( subclass ) if block_given?

        subclass.add_components( components )
        subclass.compile_message_handlers

        return subclass
end

# File lib/ravn/bde/bolt.rb, line 196
def self::validate( config )
        type = config[:type] or raise Ravn::BDE::InvalidBoltConfig, "missing `type' attribute"
        raise Ravn::BDE::InvalidBoltConfig, "invalid `type' attribute" unless
                type.match?( VALID_TYPE )

        name = config[:name]
        raise Ravn::BDE::InvalidBoltConfig, "invalid `name' attribute" if
                name && !name.match?( VALID_NAME )

        text = config[:text]
        raise Ravn::BDE::InvalidBoltConfig, "invalid `text' attribute" if
                text && !text.match?( VALID_TEXT )

        timeout = config[:timeout]
        raise Ravn::BDE::InvalidBoltConfig, "invalid `timeout` attribute" if
                timeout && ( !timeout.is_a?( Numeric ) || timeout < 0 )

        components = config[:components] || {}
        unless components.is_a?( Hash )
                raise Ravn::BDE::InvalidBoltConfig,
                        "invalid `components'; expected a Hash, got %p" % [ components.class ]
        end

        return true
end