class SBSM::AbstractTransHandler

Attributes

config_file[R]
  • config_file - Full path of YAML configuration file for shortcuts

handler_uri[R]
  • handler_uri - The handler file to be used

parser_name[R]
  • parser_name - Name defaults to 'uri'

Public Class Methods

new(name: nil, config_file: nil, handler_uri: nil) click to toggle source

arguments

  • name - Used for checking whether a 'name'.grammar or 'name'_parser.rb can be loaded

  • config_file - Where the config file can be found. Default to 'etc/trans_handler.yml'

  • handler_ur - The handler to be invoked. defaults to '/index.rbx'

# File lib/sbsm/trans_handler.rb, line 44
def initialize(name: nil, config_file: nil, handler_uri: nil)
  @handler_uri = handler_uri ||=  '/index.rbx'
  config_file ||=  'etc/trans_handler.yml'
  @config_file = File.expand_path(config_file)
  @parser_name = name ||= 'uri'
  @parser_method = "_#{name}_parser"
  @grammar_path = File.expand_path("../../data/#{name}.grammar",
    File.dirname(__FILE__))
  @parser_path = File.expand_path("#{name}_parser.rb",
    File.dirname(__FILE__))
end

Public Instance Methods

config(request) click to toggle source
# File lib/sbsm/trans_handler.rb, line 55
def config(request)
  config = Hash.new { {} }
  begin
    return config unless @config_file && File.exist?(@config_file)
    config.update(YAML.load(File.read(@config_file)))
    config
  rescue StandardError => err
    fmt = 'Unable to load url configuration: %s', @config_file
    fmt = 'Hint: store configuration in a YAML-File'
    config
  end
end
handle_shortcut(request, config) click to toggle source
  • request - A Rack::Request with our monkey patch to access :uri

  • config - config values for shortcuts (Hash of Hash)

# File lib/sbsm/trans_handler.rb, line 69
def handle_shortcut(request, config)
  if(params = config['shortcut'][request.path])
    params.each do |key, val|
      request.params[key.to_s] = val ? val : ''
    end
    request.uri = @handler_uri
  end
end
parse_uri(request) click to toggle source

The default parser for an URI

arguments

# File lib/sbsm/trans_handler.rb, line 109
                def parse_uri(request)
                        @uri_parser ||= self.uri_parser
                        ast = @uri_parser.parse(request.path)
                        values = request.params
                        ast.children_names.each { |name|
                                case name
                                when'language', 'flavor', 'event', 'zone'
#                                       values.add(name, ast.send(name).value)
                                when 'variables'
                                        ast.variables.each { |pair|
                                                key = pair.key.value
                                                val = if(pair.children_names.include?('value'))
                                                        CGI.unescape(pair.value.value.to_s)
                                                else
                                                        ''
                                                end
                                                request.update_param(key, val)
                                        }
                                end
                        }
                end
simple_parse(uri) click to toggle source
  • uri - uri to be parsed, e.g. /language/flavor/event/key/value/key/value/…

language, flavor and event are added as special keys, else values are inserted as string

# File lib/sbsm/trans_handler.rb, line 81
def simple_parse(uri)
  values = {}
  items = uri.split('/')
  items.shift
  lang = items.shift
  values.store(:language, lang) if lang
  flavor = items.shift
  values.store(:flavor, flavor) if flavor
  event = items.shift
  values.store(:event, event) if event
  until items.empty?
    key = items.shift
    value = items.shift
    values.store(key, value)
  end
  values
end
simple_parse_uri(request) click to toggle source
# File lib/sbsm/trans_handler.rb, line 99
def simple_parse_uri(request)
                    # values = request.params
  simple_parse(request.path).each do |key, value|
      request.env[key.to_s] = value ? value : ''
    request.update_param(key.to_s, CGI.unescape(value.to_s))
  end
end
translate_uri(request) click to toggle source
# File lib/sbsm/trans_handler.rb, line 131
          def translate_uri(request)
                  @@empty_check ||= Regexp.new('^/?$')
                  @@lang_check ||= Regexp.new('^/[a-z]{2}(/|$)')
uri = request.path
request.uri ||= uri
config = config(request)
handle_shortcut(request, config)
case uri
when @@empty_check
  request.uri = config['redirect']['/'] ||= @handler_uri
when @@lang_check
  begin
    self.parse_uri(request)
  rescue LoadError # this happens often
    res = simple_parse_uri(request)
  end
  request.uri = @handler_uri
end
Apache::DECLINED
          end
uri_parser(grammar_path=@grammar_path, parser_path=@parser_path) click to toggle source
# File lib/sbsm/trans_handler.rb, line 151
def uri_parser(grammar_path=@grammar_path, parser_path=@parser_path)
        if(File.exist?(grammar_path))
                oldpath = File.expand_path("_" << File.basename(grammar_path),
                        File.dirname(grammar_path))
                src = File.read(grammar_path)
                unless(File.exists?(oldpath) && File.read(oldpath)==src)
                        File.delete(oldpath) if File.exists?(oldpath)
                        Parse.generate_parser_from_file_to_file(grammar_path,
                                parser_path, @parser_method, 'SBSM')
                        File.open(oldpath, 'w') { |f| f << src }
                end
        end
        require parser_path
        SBSM.send(@parser_method)
end