handlebarer 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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,283 @@
+# Handlerbarer - Share your Handlerbars templates between client and server
+
+Handlerbars is a very popular templating engine, recently given much deserved attention due to the awesome Ember.js Framework.
+Handlebarer gives you ability to easily use Handlerbars templates for both server and client side in your Rails project.
+
+On the client-side your templates should be used with Rails' JST engine. On the server side, you can render your
+Handlerbars templates as Rails views (similar to how you'd render ERB or HAML templates).
+
+## Writing your templates
+
+Lets assume you have a users controller `app/controllers/users_controller.rb` which in turn renders a list of users.
+We'd like to share that view between the client and the server.
+
+### Server-Side code
+
+```ruby
+class UsersController < ApplicationController
+
+  def index
+    @users = User.all
+    respond_to do |format|
+      format.html
+    end
+  end
+
+end
+```
+
+To share our template between client and server, we need to place it under `app/assets/javascripts` for Sprockets' JST engine.
+
+Lets create a views directory for our shared templates `app/assets/javascripts/views` and add our template there, following Rails' naming convensions.
+
+The full template path should look like this: `app/assets/javascripts/views/users/index.jst.hsb`
+
+### Template code
+
+The most significant differences between using standard server-side Ruby-based engines like ERB or HAML and using Handlerbarer are:
+
+* No access to server-side view helpers (such as url_for)
+* No ruby-style instance variable like `@users`
+* Template code is not Ruby and has to follow Handlerbars' syntax rather than embedded Ruby syntax
+* No partials or includes (for now)
+
+Our template code should look like this:
+
+```html
+<ul class="users">
+{{#users}}
+<li>{{{link_to this}}}</li>
+{{/users}}
+</ul>
+```
+
+Note that rendering this template server-side, will be done inside your application's layout. You can write your views layout file in ERB / HAML
+and the call to `=yield` will render your Handlerbars template above.
+
+### Sharing template code
+
+Since Rails doesn't expect server-side templates to live under `app/assets` we need to add our client-side views path to Rails views lookup path.
+
+Assuming we have an initializer `app/config/initializers/jader.rb` we can add our client-side views directory like this:
+
+```ruby
+Handlerbarer.configure do |config|
+  # make your client-side views directory discoverable to Rails
+  config.views_path = Rails.root.join('app','assets','javascripts','views')
+end
+```
+
+Internally, this adds a `before_filter` to `ApplicationController::Base` that prepends the provided path to `ActionView::Context` .
+
+### Client-side code
+
+To render the same template from the client, we need to fetch our users list from the server and then call our JST template with that list.
+
+First, lets change our controller to return a JSON formatted list of users when called from the client:
+
+```ruby
+class UsersController < ApplicationController
+
+  def index
+    @users = User.all
+    respond_to do |format|
+      format.html
+      format.json {
+        render :json => @users.to_hbs
+      }
+    end
+  end
+
+end
+```
+
+Note the call to `to_hbs` on the `@users` collection. This ensures our users are properly serialized for use inside our template.
+See the [Serialization](https://github.com/zohararad/jader#serialization) section below for more details.
+
+In our `application.js` file lets write the following:
+
+```javascript
+//= require handlebars/runtime
+//= require views/users/index
+
+$.getJSON('/users', function(users){
+  $('body').html(JST['views/users/index']({users:users}));
+});
+```
+
+## Serialization
+
+To help Handlerbarer access Ruby and Rails variables inside the template, we need to employ some sort of JSON serializing before passing
+these variables to the template. On the server-side, this happens automagically before the template is rendered.
+
+Internally, Handlerbarer will try to call the `to_hbs` method on each instance variable that's passed to the template. Ruby's Hash, Array and Object classes have been extended
+to support this functionality. Arrays and Hashes will attempt to call the `to_hbs` method on their members when `to_hbs` is invoked on their instances. For
+other collection-like variables, the `to_hbs` method will only be invoked if they respond to a `to_a` method. This allows ActiveModel / ActiveRecord instance variables to
+automatically serialize their members before rendering.
+
+### Serializing models
+
+Handlerbarer does not assume your Rails models should be serialized by default. Instead, it expects you to enable serializing on desired models explicitly.
+
+To enable this behaviour, consider the following example:
+
+```ruby
+class User < ActiveRecord::Base
+
+  include Handlerbarer::Serialize
+
+  hbs_serializable :name, :email, :favorites, :merge => false
+
+end
+```
+
+The call to `include Handlerbarer::Serialize` mixes Handlerbarer::Serializer capabilities into our model class.
+
+We can then tell the serializer which attributes we'd like to serialize, and how we'd like the serialization to work.
+
+By default, calling `hbs_serializable` with no arguments will serialize all your model attributes. Lets look at two examples:
+
+Consider the following code:
+
+```ruby
+# define our model
+class User < ActiveRecord::Base
+
+  include Handlerbarer::Serialize
+
+  hbs_serializable
+
+end
+
+# access in controller
+class UsersController < ApplicationController
+
+  def index
+    @users = User.all
+    @users.to_hbs # => all available user attributes (users table columns) will be serialized
+  end
+
+  def active
+    @users = User.where('active = 1').select('name, email')
+    @users.to_hbs # => only name and email attributes are serialized
+  end
+end
+```
+
+For better control over which attributes are serialized, and when serializing model relationships, we can tell the serializer
+which attributes should always be serialized, and whether we'd like these attributes to be merged with the default attributes or not.
+
+Consider the following code:
+
+
+```ruby
+# define our models
+
+class Favorite < ActiveRecord::Base
+
+  include Handlerbarer::Serialize
+
+  hbs_serializable
+
+  belongs_to :user
+
+end
+
+class User < ActiveRecord::Base
+
+  include Handlerbarer::Serialize
+
+  hbs_serializable :favorites, :merge => true
+
+  has_many :favorites
+end
+
+# access in controller
+class UsersController < ApplicationController
+
+  def active
+    @users = User.where('active = 1').select('name, email')
+    @users.to_hbs # => only name, email and favorites attributes are serialized
+  end
+end
+```
+
+In the above, we defined serialization for the `User` model to include the `:favorites` attribute, which is available because of the `has_many` relationship
+to the `Favorite` model. Additionally, we specified that serialization should merge model default attributes with the specified attributes, by setting `:merge => true` .
+
+This will result in merging `self.attributes` and `self.favorites` on any instance of the `User` model when calling the `to_hbs` method on it.
+
+To only serialize the specified attributes, call `hbs_serializable` with `:merge => false` .
+
+Invokation format for `hbs_serializable` is:
+
+```ruby
+hbs_serializable :attr1, :attr2, :attr3 ...., :merge => true/false
+```
+
+By default, `hbs_serializable` will operate with `:merge => true` and merge instnace attributes with specified attributes.
+
+## Helpers
+
+Handlerbars has built in support for helper function registration, which is great for client-side rendering, but alas requires a
+bit of extra work for server-side rendering.
+
+Lets assume you have registered Handlebars helpers reside under `app/assets/javascripts/helpers/link.js`
+that might look something like this:
+
+```javascript
+Handlebars.registerHelper('link_to', function(context) {
+  return '<a href="/users/' + context.id + '">' + context.name + '</a>';
+});
+```
+
+On the client-side, you might add to the asset pipeline like this:
+
+```javascript
+//= require handlebars/runtime
+//= require helpers/link.js
+```
+
+To use the same helper on the server-side, you'll need to configre Handlebarer like so:
+
+```ruby
+Handlerbarer.configure do |config|
+  config.helpers_path = Rails.root.join('app','assets','javascripts','helpers')
+end
+```
+
+When rendering your Handlebars template server-side, Handlerbarer will look for any Javascript file in the helpers path and
+include it in the rendering context.
+
+Please note that at the moment, Handlebarer only supports Javascript helper files rather than both Javascript and CoffeeScript.
+
+## Configuration
+
+Its recommended to configure Handlerbarer inside a Rails initializer so that configuration is defined at boot time.
+
+Assuming we have an initializer `app/config/initializers/jader.rb` it should include:
+
+```ruby
+Handlerbarer.configure do |config|
+  # tell Handlebarer where to find your Handlebars helpers
+  config.helpers_path = Rails.root.join('app','assets','javascripts','helpers')
+  # make your client-side views directory discoverable to Rails
+  config.views_path = Rails.root.join('app','assets','javascripts','views')
+end
+```
+
+## Asset Pipeline
+
+In case your Rails asset pipeline is configured **not** to load the entire Rails environment when calling `rake assets:precompile`, you should include Handlerbarer's configuration initalizer in your Rakefile.
+
+Simply add `require File.expand_path('../config/initializers/handlebarer', __FILE__)` before `require File.expand_path('../config/application', __FILE__)` in your Rakefile, and ensure Handlerbarer is properly configured when your assets are precompiled
+
+# License
+
+Copyright (c) 2013 Zohar Arad <zohar@zohararad.com>
+
+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/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+Bundler::GemHelper.install_tasks
+

data/lib/handlebarer/compiler.rb

@@ -0,0 +1,69 @@
+require 'v8'
+
+module Handlebarer
+  class Compiler
+
+    # Handlerbars template engine Javascript source code used to compile templates in ExecJS
+    # @return [String] Handlerbars source code
+    def source
+      @source ||= Handlebarer::Source::handlebars
+    end
+
+    # V8 context with Handlerbars code compiled
+    # @yield [context] V8::Context compiled Handlerbars source code in V8 context
+    def v8_context
+      V8::C::Locker() do
+        context = V8::Context.new
+        context.eval(source)
+        yield context
+      end
+    end
+
+    # Handlerbars Javascript engine version
+    # @return [String] version of Handlerbars javascript engine installed in `vendor/assets/javascripts`
+    def handlebars_version
+      v8_context do |context|
+        context.eval("Handlebars.VERSION")
+      end
+    end
+
+    # Compile a Handlerbars template for client-side use with JST
+    # @param [String, File] template Handlerbars template file or text to compile
+    # @return [String] Handlerbars template compiled into Javascript and wrapped inside an anonymous function for JST
+    def compile(template)
+      v8_context do |context|
+        template = template.read if template.respond_to?(:read)
+        compiled_handlebars = context.eval("Handlebars.precompile(#{template.to_json})")
+        "Handlebars.template(#{compiled_handlebars});"
+      end
+    end
+
+    # Compile and evaluate a Handlerbars template for server-side rendering
+    # @param [String] template Handlerbars template text to render
+    # @param [Hash] vars controller instance variables passed to the template
+    # @return [String] HTML output of compiled Handlerbars template
+    def render(template, vars = {})
+      v8_context do |context|
+        unless Handlebarer.configuration.nil?
+          helpers = handlebars_helpers
+          context.eval(helpers.join("\n")) if helpers.any?
+        end
+        context.eval("var fn = Handlebars.compile(#{template.to_json})")
+        context.eval("fn(#{vars.to_hbs.to_json})")
+      end
+    end
+
+    # Handlebars helpers
+    # @return [Array<String>] array of Handlebars helpers to use with a Handlebars template rendered by a Rails controller
+    def handlebars_helpers
+      helpers = []
+      unless Handlebarer.configuration.helpers_path.nil?
+        Dir["#{Handlebarer.configuration.helpers_path}/*.js"].each do |f|
+          helpers << IO.read(f)
+        end
+      end
+      helpers
+    end
+
+  end
+end

data/lib/handlebarer/configuration.rb

@@ -0,0 +1,28 @@
+module Handlebarer
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Configure Handlebarer
+  # @yield [config] Handlebarer::Configuration instance
+  # @example
+  #     Handlebarer.configure do |config|
+  #       config.helpers_path = Rails.root.join('app','assets','javascripts','helpers')
+  #       config.views_path = Rails.root.join('app','assets','javascripts','views')
+  #     end
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  # Jader configuration class
+  class Configuration
+    attr_accessor :helpers_path, :views_path
+
+    # Initialize Jader::Configuration class with default values
+    def initialize
+      @helpers_path = nil
+      @views_path = nil
+    end
+  end
+end

data/lib/handlebarer/engine.rb

@@ -0,0 +1,22 @@
+require 'sprockets'
+require 'sprockets/engines'
+
+module Handlebarer
+  class Engine < Rails::Engine
+    initializer 'handlebarer.configure_rails_initialization', :before => 'sprockets.environment', :group => :all do |app|
+      next unless app.config.assets.enabled
+      Sprockets.register_engine '.hbs', ::Handlebarer::Template
+      Sprockets.register_engine '.handlebars', ::Handlebarer::Template
+    end
+
+    initializer 'handlebarer.prepend_views_path', :after => :add_view_paths do |app|
+      next if Handlebarer::configuration.nil? or Handlebarer::configuration.views_path.nil?
+      ActionController::Base.class_eval do
+        before_filter do |controller|
+          prepend_view_path Handlebarer::configuration.views_path
+        end
+      end
+    end
+
+  end
+end

data/lib/handlebarer/renderer.rb

@@ -0,0 +1,40 @@
+module Handlebarer
+  # Server side Jade templates renderer
+  module Renderer
+
+    # Convert Handlebars template to HTML output for rendering as a Rails view
+    # @param [String] template_text Handlebars template text to convert
+    # @param [String] controller_name name of Rails controller rendering the view
+    # @param [Hash] vars controller instance variables passed to the template
+    # @return [String] HTML output of evaluated template
+    # @see Handlebarer::Compiler#render
+    def self.convert_template(template_text, vars = {})
+      compiler = Handlebarer::Compiler.new
+      compiler.render(template_text, vars)
+    end
+
+    # Prepare controller instance variables for the template and execute template conversion.
+    # Called as an ActionView::Template registered template
+    # @param [ActionView::Template] template currently rendered ActionView::Template instance
+    # @see Handlebarer::Renderer#convert_template
+    def self.call(template)
+      #template.source.gsub!(/\#\{([^\}]+)\}/,"\\\#{\\1}") # escape Handlebars' #{somevariable} syntax
+      %{
+        template_source = %{#{template.source}}
+        variable_names = controller.instance_variable_names
+        variable_names -= %w[@template]
+        if controller.respond_to?(:protected_instance_variables)
+          variable_names -= controller.protected_instance_variables
+        end
+
+        variables = {}
+        variable_names.each do |name|
+          next if name.include? '@_'
+          variables[name.sub(/^@/, "")] = controller.instance_variable_get(name)
+        end
+        Handlebarer::Renderer.convert_template(template_source, variables.merge(local_assigns))
+      }
+    end
+
+  end
+end

data/lib/handlebarer/serialize.rb

@@ -0,0 +1,107 @@
+module Handlebarer
+
+  module Serialize
+
+    module ClassMethods
+
+      # Enable serialization on ActiveModel classes
+      # @param [Array<Symbol>] args model attribute names to serialize
+      # @param [Hash] args options serializing mode
+      # @option args [Boolean] :merge should serialized attributes be merged with `self.attributes`
+      # @example
+      #     class User < ActiveRecord::Base
+      #       include Handlebarer::Serialize
+      #       hbs_serializable :name, :email, :merge => false
+      #     end
+      def hbs_serializable(*args)
+        serialize = {
+          :attrs => [],
+          :merge => true
+        }
+        args.each do |arg|
+          if arg.is_a? Symbol
+            serialize[:attrs] << arg
+          elsif arg.is_a? Hash
+            serialize[:merge] = arg[:merge] if arg.include?(:merge)
+          end
+        end
+        class_variable_set(:@@serialize, serialize)
+      end
+
+    end
+
+    #nodoc
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Serialize instance attributes to a Hash based on serializable attributes defined on Model class.
+    # @return [Hash] hash of model instance attributes
+    def to_hbs
+      h = {:model => self.class.name.downcase}
+      self.hbs_attributes.each do |attr|
+        h[attr] = self.send(attr)
+
+        ans = h[attr].class.ancestors
+        if h[attr].class.respond_to?(:hbs_serializable) || ans.include?(Enumerable) || ans.include?(ActiveModel::Validations)
+          h[attr] = h[attr].to_hbs
+        else
+        end
+      end
+      h
+    end
+
+    # List of Model attributes that should be serialized when called `to_hbs` on Model instance
+    # @return [Array] list of serializable attributes
+    def hbs_attributes
+      s = self.class.class_variable_get(:@@serialize)
+      if s[:merge]
+        attrs = s[:attrs] + self.attributes.keys
+      else
+        attrs = s[:attrs]
+      end
+      attrs.collect{|attr| attr.to_sym}.uniq
+    end
+  end
+
+end
+
+class Object
+  # Serialize Object to Jade format. Invoke `self.to_hbs` if instance responds to `to_hbs`
+  def to_hbs
+    if self.respond_to? :to_a
+      self.to_a.to_hbs
+    else
+      nil
+    end
+  end
+end
+
+#nodoc
+[FalseClass, TrueClass, Numeric, String].each do |cls|
+  cls.class_eval do
+    def to_hbs
+      self
+    end
+  end
+end
+
+class Array
+
+  # Serialize Array to Handlebarer format. Invoke `to_hbs` on array members
+  def to_hbs
+    map {|a| a.respond_to?(:to_hbs) ? a.to_hbs : a }
+  end
+end
+
+class Hash
+
+  # Serialize Hash to Handlebarer format. Invoke `to_hbs` on members
+  def to_hbs
+    res = {}
+    each_pair do |key, value|
+      res[key] = (value.respond_to?(:to_hbs) ? value.to_hbs : value)
+    end
+    res
+  end
+end

data/lib/handlebarer/source.rb

@@ -0,0 +1,26 @@
+module Handlebarer
+  # Handlebars template engine Javascript source code
+  module Source
+
+    # Handlebars source code
+    def self.handlebars
+      IO.read handlebars_path
+    end
+
+    # Handlebars source code path
+    def self.handlebars_path
+      File.expand_path("../../../vendor/assets/javascripts/handlebars/handlebars.js", __FILE__)
+    end
+
+    # Handlebars runtime source code
+    def self.runtime
+      IO.read runtime_path
+    end
+
+    # Handlebars runtime source code path
+    def self.runtime_path
+      File.expand_path("../../../vendor/assets/javascripts/handlebars/runtime.js", __FILE__)
+    end
+
+  end
+end

data/lib/handlebarer/template.rb

@@ -0,0 +1,30 @@
+require 'tilt/template'
+
+module Handlebarer
+
+  # Handlebarer Tilt template for use with JST
+  class Template < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    # Ensure V8 is available when engine is initialized
+    def self.engine_initialized?
+      defined? ::V8
+    end
+
+    # Require 'execjs' when initializing engine
+    def initialize_engine
+      require_template_library 'v8'
+    end
+
+    def prepare
+    end
+
+    # Evaluate the template. Compiles the template for JST
+    # @return [String] JST-compliant compiled version of the Handlebars template being rendered
+    def evaluate(scope, locals, &block)
+      c = Handlebarer::Compiler.new
+      c.compile(data)
+    end
+
+  end
+end

data/lib/handlebarer/version.rb

@@ -0,0 +1,3 @@
+module Handlebarer
+  VERSION = "0.0.1"
+end

data/lib/handlebarer.rb

@@ -0,0 +1,12 @@
+require 'handlebarer/source'
+require 'handlebarer/compiler'
+require 'handlebarer/template'
+require 'handlebarer/engine' if defined?(::Rails)
+require 'handlebarer/renderer'
+require 'handlebarer/serialize'
+require 'handlebarer/configuration'
+
+ActionView::Template.register_template_handler :handlebars, Handlebarer::Renderer
+ActionView::Template.register_template_handler :hbs, Handlebarer::Renderer
+ActionView::Template.register_template_handler 'jst.handlebars', Handlebarer::Renderer
+ActionView::Template.register_template_handler 'jst.hbs', Handlebarer::Renderer

data/lib/tasks/handlebarer_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :handlebarer do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: handlebarer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Zohar Arad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tilt
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: therubyracer
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: libv8
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.11.8
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.11.8
+    none: false
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: rails
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+    none: false
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Share your Handlebars views between client and server, eliminate code
+  duplication and make your single-page app SEO friendly
+email:
+- zohar@zohararad.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/handlebarer/compiler.rb
+- lib/handlebarer/configuration.rb
+- lib/handlebarer/engine.rb
+- lib/handlebarer/renderer.rb
+- lib/handlebarer/serialize.rb
+- lib/handlebarer/source.rb
+- lib/handlebarer/template.rb
+- lib/handlebarer/version.rb
+- lib/handlebarer.rb
+- lib/tasks/handlebarer_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: https://github.com/zohararad/handlebarer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: JST and Rails views compiler for Handlebars templates
+test_files: []