Class: Configuration::Handler

Inherits:

Scope

• Object
• Scope
• Configuration::Handler

Defined in:

lib/httpimagestore/configuration/handler.rb

Class Method Summary

• .match(node) ⇒ Object
• .parse(configuration, node) ⇒ Object
• .post(configuration) ⇒ Object
• .pre(configuration) ⇒ Object

Methods inherited from Scope

#initialize, node_parsers, #parse, register_node_parser

Constructor Details

This class inherits a constructor from Configuration::Scope

Class Method Details

.match(node) ⇒ Object

# File 'lib/httpimagestore/configuration/handler.rb', line 278

def self.match(node)
	node.name == 'put' or
	node.name == 'post' or
	node.name == 'get'
end

.parse(configuration, node) ⇒ Object

# File 'lib/httpimagestore/configuration/handler.rb', line 288

def self.parse(configuration, node)
	handler_configuration =
		Struct.new(
			:global,
			:http_method,
			:uri_matchers,
			:sources,
			:processors,
			:stores,
			:output
		).new

	handler_configuration.global = configuration
	handler_configuration.http_method = node.name
	handler_configuration.uri_matchers = node.values.map do |matcher|
		case matcher
		# URI matchers
		when %r{^:([^/]+)/(.*)/$} # :foobar/.*/
			name = $1.to_sym
			_regexp = Regexp.new($2)
			regexp = Regexp.new("(#{$2})")
			Matcher.new([name], 'Regexp', _regexp) do
				regexp
			end
		when %r{^/(.*)/$} # /.*/
			regexp = $1
			_regexp = Regexp.new($1)
			names = Regexp.new($1).names.map{|n| n.to_sym}
			Matcher.new(names, 'Regexp', _regexp) do
				-> {
					matchdata = env["PATH_INFO"].match(/\A\/(?<_match_>#{regexp})(?<_tail_>(?:\/|\z))/)

					next false unless matchdata

					path, *vars = matchdata.captures

					env["SCRIPT_NAME"] += "/#{path}"
					env["PATH_INFO"] = "#{vars.pop}#{matchdata.post_match}"

					captures.push(*vars)
				}
			end
		when /^:(.+)\?(.*)$/ # :foo?bar
			name = $1.to_sym
			default = $2
			Matcher.new([name], 'SegmentDefault', "<segment>|#{default}") do
				->{match(name) || captures.push(default)}
			end
		when /^:(.+)$/ # :foobar
			name = $1.to_sym
			Matcher.new([name], 'Segment', '<segment>') do
				name
			end
		# Query string matchers
		when /^\&([^=]+)=(.+)$/# ?foo=bar
			name = $1.to_sym
			value = $2
			Matcher.new([name], 'QueryKeyValue', "#{name}=#{value}") do
				->{req[name] && req[name] == value && captures.push(req[name])}
			end
		when /^\&:(.+)\?(.*)$/# &:foo?bar
			name = $1.to_sym
			default = $2
			Matcher.new([name], 'QueryKeyDefault', "#{name}=<key>|#{default}") do
				->{captures.push(req[name] || default)}
			end
		when /^\&:(.+)$/# &:foo
			name = $1.to_sym
			Matcher.new([name], 'QueryKey', "#{name}=<key>") do
				->{req[name] && captures.push(req[name])}
			end
		# Literal URI segment matcher
		else # foobar
			Matcher.new([], "Literal", matcher) do
				Regexp.escape(matcher)
			end
		end
	end
	handler_configuration.sources = []
	handler_configuration.processors = []
	handler_configuration.stores = []
	handler_configuration.output = nil

	node.grab_attributes

	if handler_configuration.http_method != 'get'
		handler_configuration.sources << InputSource.new
	end

	configuration.handlers << handler_configuration

	self.new(handler_configuration).parse(node)

	handler_configuration.output = OutputOK.new unless handler_configuration.output
end

.post(configuration) ⇒ Object

# File 'lib/httpimagestore/configuration/handler.rb', line 384

def self.post(configuration)
	log.warn 'no handlers configured' if configuration.handlers.empty?
end

.pre(configuration) ⇒ Object

# File 'lib/httpimagestore/configuration/handler.rb', line 284

def self.pre(configuration)
	configuration.handlers ||= []
end