https://github.com/andreapavoni/panoramic
store rails views on database instead of filesystem
https://github.com/andreapavoni/panoramic
Last synced: about 1 year ago
JSON representation
store rails views on database instead of filesystem
- Host: GitHub
- URL: https://github.com/andreapavoni/panoramic
- Owner: andreapavoni
- License: mit
- Created: 2011-06-08T10:43:37.000Z (about 15 years ago)
- Default Branch: master
- Last Pushed: 2024-05-31T08:16:49.000Z (about 2 years ago)
- Last Synced: 2025-03-31T11:06:55.935Z (over 1 year ago)
- Language: Ruby
- Homepage:
- Size: 84 KB
- Stars: 171
- Watchers: 8
- Forks: 63
- Open Issues: 10
-
Metadata Files:
- Readme: README.md
- License: MIT-LICENSE
Awesome Lists containing this project
README
# Panoramic [](http://travis-ci.org/apeacox/panoramic)
An [ActionView::Resolver] implementation to store rails views (layouts, templates and partials) on database. Simply put: what you can do with views on filesystem, can be done on database.
**NOTE:** at the moment, only ActiveRecord is supported, I've planned to add more ORMs (see Todo). If you can't wait, adding other ORMs should be very trivial.
## Installation
Add the following line to Gemfile:
```ruby
gem "panoramic"
```
## Usage
### Mandatory fields
Your model should have the following fields:
* body (text): the source of template
* path (string): where to find template (ex: layouts/application,
you_controller/action, etc...)
* locale (string): it depends from available locales in your app
* handler (string): as locale field, it depends from avaiable handlers
(erb, haml, etc...)
* partial (boolean): determines if it's a partial or not (false by
default)
* format (string): A valid mimetype from Mime::SET.symbols
they're what the rails' Resolver API needs to lookup templates.
### Model
A simple macro in model will activate your new Resolver. You can use a dedicated model to manage all the views in your app, or just for specific needs (ex: you want a custom template for some static pages, the other views will be fetched from filesystem).
```ruby
class TemplateStorage < ActiveRecord::Base
store_templates
end
```
### Controller
To add Panoramic::Resolver in controller, depending on your needs, you may choose:
* [prepend_view_path]: search for templates *first* in your resolver, *then* on filesystem
* [append_view_path]: search for templates *first* on filesystem, *then* in your resolver
**NOTE**: the above methods are both class and instance methods.
```ruby
class SomeController < ApplicationController
prepend_view_path TemplateStorage.resolver
def index
# as you may already know, rails will serve 'some/index' template by default, but it doesn't care where it is stored.
end
def show
# explicit render
render :template => 'custom_template'
end
def custom_template
# use another model to fetch templates
prepend_view_path AnotherModel.resolver
end
end
```
And let's say you want to use database template resolving in all your controllers, but
want to use panoramic only for certain paths (prefixed with X) you can use
```ruby
class ApplicationController < ActionController::Base
prepend_view_path TemplateStorage.resolver(:only => 'use_this_prefix_only')
end
```
This helps reducing the number of database requests, if Rails for example tries to look
for layouts per controller.
### ActionMailer
```ruby
class MyEmail < ActionMailer::Base
prepend_view_path TemplateStorage.resolver
```
Using prepend_view_path/append_view_path you are stuck to the current context (e.g. the method calling "mail").
If you want to dynamically change the path depending on a certain variable, call the prepend_view_path/append_view_path inside the method's context with an additional path variable.
This could be useful, if you want to use only one method for sending different templates depending on the template.path .
```ruby
class MyEmail < ActionMailer::Base
def method_that_sets_resolver_path
prepend_view_path TemplateStorage.resolver(:path => model.path)
end
```
## Documentation
Need more help? Check out ```spec/dummy/```, you'll find a *dummy* rails app I used to make tests ;-)
## Testing
Enter Panoramic gem path, run ```bundle install``` to install development and test dependencies, then ```rake spec```.
## Todo
### Long term
* add generators
## Contributing
Fork, make your changes, then send a pull request.
## Credits
The main idea was *heavily inspired* from José Valim's awesome book [Crafting Rails Applications]. It helped me to better understand some Rails internals.
[ActionView::Resolver]: http://api.rubyonrails.org/classes/ActionView/Resolver.html
[append_view_path]: http://apidock.com/rails/AbstractController/ViewPaths/ClassMethods/append_view_path
[prepend_view_path]: http://apidock.com/rails/AbstractController/ViewPaths/ClassMethods/prepend_view_path
[Crafting Rails Applications]: http://pragprog.com/titles/jvrails/crafting-rails-applications