Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 564c06ff51
Fetching contributors…

Cannot retrieve contributors at this time

111 lines (99 sloc) 3.936 kb
/*
* Copyright 2010-2011 WorldWide Conferencing, LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.liftweb
package http
import java.util.{ResourceBundle, Locale}
import common._
import util._
/**
* Many routines in Lift can be customized in LiftRules,
* but have default behaviors. This singleton contains
* the default routines. <b>**DO NOT**</b> call these methods
* directly. Use LiftRules to call them. So, why make them
* public? So, we can document the default behaviors.
*/
object DefaultRoutines {
private val resourceMap: LRUMap[(String, List[String]),
Box[ResourceBundle]] =
new LRUMap(2000)
private def rawResBundle(loc: Locale, path: List[String]): Box[ResourceBundle] = {
val realPath = path match {
case Nil => List("_resources")
case x => x
}
for {
xml <- Templates(realPath, loc) or
Templates("templates-hidden" :: realPath, loc) or
Templates(realPath.dropRight(1) :::
("resources-hidden" ::
realPath.takeRight(1)), loc)
bundle <- BundleBuilder.convert(xml, loc)
} yield bundle
}
private def resBundleFor(loc: Locale, path: List[String]): Box[ResourceBundle] =
resourceMap.synchronized {
val key = loc.toString -> path
resourceMap.get(key) match {
case Full(x) => x
case _ => {
val res = rawResBundle(loc, path)
if (!Props.devMode) resourceMap(key) = res
res
}
}
}
/**
* Returns the resources for the current request. In development
* mode, these resources will be reloaded on each request. In
* production mode, the resources will be cached (up to 2000
* resource bundles will be cached). <br/><br/>
*
* The resource bundles will be loaded using Templates and converted
* via BundleBuilder. The routine will search for resources given the
* current Locale (see S.locale). If the current path is /foo/bar,
* the files /foo/_resources_bar, /templates-hidden/foo/_resources_bar,
* and /foo/resources-hidden/_resources_bar will be searched. The
* search will be based on the Templates locale search rules. <br/><br/>
*
* In addition to page-specific resources, there are global resources searched
* in /_resources, /templates-hidden/_resources, and
* /resources-hidden/_resources. <br/><br/>
*
* This resource loading mechanism offers global and per-page
* localization. It's based on the template loading mechanism
* so that localization is stored in UTF-8 and as XML so there's no
* wacky encoding or compilation as is necessary with standard Java
* resource bundles. Further, the per-page resources are available
* right next to the pages themselves in the source tree, so it's
* easier to remember to update the localization.
*
* @see S.locale
* @see Templates.apply
* @see BundleBuilder.convert
*
*/
def resourceForCurrentReq(): List[ResourceBundle] = {
val loc = S.locale
val cb =
for {
req <- S.originalRequest
path = req.path.partPath.dropRight(1) :::
req.path.partPath.takeRight(1).map(s => "_resources_"+s)
bundle <- resBundleFor(loc, path)
} yield bundle
cb.toList ::: resBundleFor(loc, Nil).toList
}
}
Jump to Line
Something went wrong with that request. Please try again.