flavour_saver 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d12597ba5058729046ad752a861932197e839cf
+  data.tar.gz: e1975090088071c306eff750d6f45b9155bf0cce
+SHA512:
+  metadata.gz: d09d2f9c685d5fb79c1e86df08d01865f4b108551c67e45e754dae94483f8f739e133cf744ba0d0d9548e9365e83f579b47bad21043927b80694bba36cc6e493
+  data.tar.gz: 97dc6cd9a74bca558a20f0cca63ff552e7fc0a69a9a94ea38dedbc21c74e4b25c5433f288823e74db8ac69b5e36a6b9607ee9f4493347f66e909cce99eb6d37e

data/.gitignore

@@ -0,0 +1,16 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+script: 'bundle exec rspec'
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in flavour_saver.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,81 @@
+PATH
+  remote: .
+  specs:
+    flavour_saver (0.3.3)
+      rltk (~> 2.2.0)
+      tilt
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    coderay (1.0.9)
+    diff-lcs (1.2.4)
+    ffi (1.9.0)
+    formatador (0.2.4)
+    guard (1.8.3)
+      formatador (>= 0.2.4)
+      listen (~> 1.3)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-bundler (1.0.0)
+      bundler (~> 1.0)
+      guard (~> 1.1)
+    guard-rspec (3.1.0)
+      guard (>= 1.8)
+      rspec (~> 2.13)
+    i18n (0.6.5)
+    listen (1.3.1)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    lumberjack (1.0.4)
+    method_source (0.8.2)
+    minitest (4.7.5)
+    multi_json (1.8.0)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.2)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    rltk (2.2.1)
+      ffi (>= 1.0.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    slop (3.4.6)
+    thor (0.18.1)
+    thread_safe (0.1.3)
+      atomic
+    tilt (1.4.1)
+    tzinfo (0.3.37)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  flavour_saver!
+  guard-bundler
+  guard-rspec
+  rake
+  rspec-core
+  rspec-expectations
+  rspec-mocks

data/Guardfile

@@ -0,0 +1,12 @@
+guard 'rspec', version: 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/fixtures/(.+)\.(hbs|handlebars)}) { |m| "spec/acceptance/#{m[1]}_spec.rb" }
+end
+
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Resistor Limited.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,339 @@
+# FlavourSaver
+
+[Handlebars.js](http://handlebarsjs.com) without the `.js`
+
+[![Build Status](https://travis-ci.org/jamesotron/FlavourSaver.png)](https://travis-ci.org/jamesotron/FlavourSaver)
+[![Dependency Status](https://gemnasium.com/jamesotron/FlavourSaver.png)](https://gemnasium.com/jamesotron/FlavourSaver)
+[![Code Climate](https://codeclimate.com/github/jamesotron/FlavourSaver.png)](https://codeclimate.com/github/jamesotron/FlavourSaver)
+
+## WAT?
+
+FlavourSaver is a ruby-based implementation of the [Handlebars.js](http://handlebars.js)
+templating language. FlavourSaver supports Handlebars template rendering natively on
+Rails and on other frameworks (such as Sinatra) via Tilt.
+
+Please use it, break it, and send issues/PR's for improvement.
+
+## License
+
+FlavourSaver is Copyright (c) 2013 Resistor Limited and licensed under the terms
+of the MIT Public License (see the LICENSE file included with this distribution
+for more details).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'flavour_saver'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flavour_saver
+
+## Usage
+
+FlavourSaver provides an interface to the amazing
+[Tilt](https://github.com/rtomayko/tilt) templating library, meaning that it
+should work with anything that has Tilt support (Sinatra, etc) and has a
+native Rails template handler.
+
+## Status
+
+FlavourSaver is in its infancy, your pull requests are greatly appreciated.
+
+Currently supported:
+
+  - Full support of Mustache and Handlebars templates.
+  - Expressions:
+    - with object-paths (`{{some.method.chain}}`)
+    - containing object-literals (`{{object.['index'].method}}`):
+      Ruby's `:[](index)` method is called for literals, making FlavourSaver
+      compatible with `Hash` and hashlike objects.
+    - with list arguments (`{{method arg1 "arg2"}}`)
+    - with hash arguments (`{{method foo=bar bar="baz"}}`)
+    - with list and hash arguments (`{{method arg1 arg2 foo=bar bar="baz"}}`)
+      provided that the hash is the last argument.
+    - Comments (`{{! a comment}}`)
+    - Expression output is HTML escaped
+  - Safe expressions
+    - Expressions wrapped in triple-stashes are not HTML escaped (`{{{an expression}}}`)
+  - Block expressions
+    - Simple API for adding block helpers.
+    - Block expressions with inverse blocks
+    - Inverse blocks
+  - Partials
+
+## Helpers
+
+FlavourSaver implements the following helpers by default:
+
+### #with
+
+Yields its argument into the context of the block contents:
+
+```handlebars
+{{#with person}}
+  {{name}}
+{{/with}}
+```
+
+### #each
+
+Takes a single collection argument and yields the block's contents once
+for each member of the collection:
+
+```handlebars
+{{#each people}}
+  {{name}}
+{{/each}}
+```
+
+### #if
+
+Takes a single argument and yields the contents of the block if that argument
+is truthy.
+
+```handlebars
+{{#if person}}
+  Hi {{person.name}}!
+{{/if}}
+```
+
+It can also handle a special case `{{else}}` expression:
+
+```handlebars
+{{#if person}}
+  Hi {{person.name}}!
+{{else}}
+  Nobody to say hi to.
+{{/if}}
+```
+
+### #unless
+
+Exactly the same is `#if` but backwards.
+
+### this
+
+In JavaScript `this` is a native keyword, in Ruby not-so-much. FlavourSaver's `this` helper
+returns `self`:
+
+```handlebars
+{{#each names}}
+  {{this}}
+{{/each}}
+```
+
+### log
+
+Writes log output.  The destination can be changed by assigning a `Logger` instance to
+`FlavourSaver.logger=`.  On Rails `FlavourSaver.logger` automatically points at
+`Rails.logger`.
+
+### Adding additional helpers
+
+Additional helpers can easy be added by calling `FS.register_helper`, eg:
+
+```ruby
+FS.register_helper(:whom) { 'world' }
+```
+
+Now if you were to render the following template:
+
+```handlebars
+<h1>Hello {{whom}}!</h1>
+```
+
+You would receive the following output:
+
+```html
+<h1>Hello world!</h1>
+```
+
+### Adding block helpers
+
+Creating a block helper works exactly like adding a regular helper, except that
+the helper implementation can call `yield.contents` one or more times, with an
+optional argument setting the context of the block execution:
+
+```ruby
+FS.register_helper(:three_times) do
+  yield.contents
+  yield.contents
+  yield.contents
+end
+```
+
+Which when called with the following template:
+
+```handlebars
+{{#three_times}}
+  hello
+{{/three_times}}
+```
+
+would result in the following output:
+```
+  hello
+  hello
+  hello
+```
+
+Implementing a simple iterator is dead easy:
+
+```ruby
+FS.register_helper(:list_people) do |people|
+  people.each do |person|
+    yield.contents person
+  end
+end
+```
+
+Which could be used like so:
+
+```handlebars
+{{#list_people people}}
+  <b>{{name}}<b><br />
+  Age: {{age}}<br />
+  Sex: {{sex}}<br />
+{{/list_people}}
+```
+
+Block helpers can also contain an `{{else}}` statement, which, when used creates
+a second set of block contents (called `inverse`) which can be yielded to the output:
+
+```ruby
+FS.register_helper(:isFemale) do |person,&block|
+  if person.sex == 'female'
+    block.call.contents
+  else
+    block.call.inverse
+  end
+end
+```
+
+You can also register an existing method:
+
+```ruby
+def isFemale(person)
+  if person.sex == 'female'
+    yield.contents
+  else
+    yield.inverse
+  end
+end
+
+FS.register_helper(method(:isFemale))
+```
+
+Which could be used like so:
+
+```handlebars
+{{#isFemale person}}
+  {{person.name}} is female.
+{{else}}
+  {{person.name}} is male.
+{{/isFemale}}
+```
+
+### Using Partials
+
+Handlebars allows you to register a partial either as a function or a string template with
+the engine before compiling, FlavourSaver retains this behaviour (with the notable exception
+of within Rails - see below).
+
+To register a partial you call `FlavourSaver.register_partial` with a name and a string:
+
+```ruby
+FlavourSaver.register_partial(:my_partial, "{{this}} is a partial")
+```
+
+You can then use this partial within your templates:
+
+```handlebars
+{{#each people}}{{> my_partial this}}{{/each}}
+```
+
+## Using with Rails
+
+One potential gotcha of using FlavourSaver with Rails is that FlavourSaver doesn't let you
+have any access to the controller's instance variables. This is done to maintain compatibility
+with the original JavaScript implementation of Handlebars so that templates can be used on
+both the server and client side without any change.
+
+When accessing controller instance variables you should access them by way of a helper method
+or a presenter object.
+
+For example, in `ApplicationController.rb` you may have a `before_filter` which authenticates
+the current user's session cookie and stores it in the controller's `@current_user` instance
+variable.
+
+To access this variable you could create a simple helper method in `ApplicationHelpers`:
+
+```ruby
+def current_user
+  @current_user
+end
+```
+
+Which would mean that you are able to access it in your template:
+
+```handlebars
+{{#if current_user}}
+  Welcome back, {{current_user.first_name}}!
+{{/if}}
+```
+
+## Using the Tilt Interface Directly
+
+You can use the registered Tilt interface directly to render template strings with a hash of template variables.
+
+The Tilt template's `render` method expects an object that can respond to messages using dot notation. In the following example, the template variable `{{foo}}` will result in a call to `.foo` on the `data` object. For this reason the `data` object can't be a simple hash. A model would work, but if you have a plain old Ruby hash, use it to create a new OpenStruct object, which will provide the dot notation needed.
+
+```ruby
+template = Tilt['handlebars'].new { "{{foo}} {{bar}}" }
+data = OpenStruct.new foo: "hello", bar: "world"
+
+template.render data # => "hello world"
+```
+
+### Special behaviour of Handlebars' partial syntax
+
+In Handlebars.js all partial templates must be pre-registered with the engine before they are
+able to be used.  When running inside Rails FlavourSaver modifies this behaviour to use Rails'
+render partial helper:
+
+```handlebars
+{{> my_partial}}
+```
+
+Will be translated into:
+
+```ruby
+render :partial => 'my_partial'
+```
+
+Handlebars allows you to send a context object into the partial, which sets the execution
+context of the partial.  In Rails this behaviour would be confusing and non-standard, so
+instead any argument passed to the partial is evaluated and passed to the partial's
+`:object` argument:
+
+```handlebars
+{{> my_partial my_context}}
+```
+
+```ruby
+render :partial => 'my_partial', :object => my_context
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request