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 281

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 291

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 387

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

.pre(configuration) ⇒ Object

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

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