sinatra-backbone 0.1.0.rc1

data/.gitignore

@@ -0,0 +1 @@
+/doc

data/HISTORY.md

@@ -0,0 +1,4 @@
+v0.1.0.rc1 - Sept 12, 2011
+--------------------------
+
+Initial version.

data/README.md

@@ -0,0 +1,47 @@
+# Sinatra-backbone
+#### Neat integration of Backbone.js with Sinatra
+
+Do you like [Backbone.js][bb]? Do you like [Sinatra][sn]? Did you ever wish you 
+can use them together? Well now you can, with the new Sinatra Backbone!
+
+[bb]: http://documentcloud.github.com/backbone/
+[sn]: http://sinatrarb.com
+
+#### Usage
+
+This is a Ruby gem.  
+`$ gem install sinatra-backbone --pre`
+
+Or do you use Bundler?  
+`gem 'sinatra-backbone', :require => 'sinatra/backbone'`
+
+Contents
+--------
+
+__Sinatra-backbone__ is comprised of two Sinatra plugins:
+
+ * `Sinatra::JstPages` – Provides support for JavaScript server templates (JST) 
+  for use in Backbone views.
+
+ * `Sinatra::RestAPI` – Provides restful API for your models for use in Backbone 
+ models.
+
+For usage and API reference, please see http://ricostacruz.com/sinatra-backbone. [](#api_reference)
+
+Acknowledgements
+----------------
+
+© 2011, Rico Sta. Cruz. Released under the [MIT 
+License](http://www.opensource.org/licenses/mit-license.php).
+
+Sinatra-Backbone is authored and maintained by [Rico Sta. Cruz][rsc] with help 
+from it's [contributors][c]. It is sponsored by my startup, [Sinefunc, Inc][sf].
+
+ * [My website](http://ricostacruz.com) (ricostacruz.com)
+ * [Sinefunc, Inc.](http://sinefunc.com) (sinefunc.com)
+ * [Github](http://github.com/rstacruz) (@rstacruz)
+ * [Twitter](http://twitter.com/rstacruz) (@rstacruz)
+
+[rsc]: http://ricostacruz.com
+[c]:   http://github.com/rstacruz/xxxxx
+[sf]:  http://sinefunc.com

data/Rakefile

@@ -0,0 +1,31 @@
+desc "Invokes the test suite in multiple RVM environments"
+task :'test!' do
+  # Override this by adding RVM_TEST_ENVS=".." in .rvmrc
+  envs = ENV['RVM_TEST_ENVS'] || '1.9.2@sinatra,1.8.7@sinatra'
+  puts "* Testing in the following RVM environments: #{envs.gsub(',', ', ')}"
+  system "rvm #{envs} rake test" or abort
+end
+
+desc "Runs tests"
+task :test do
+  Dir['test/*_test.rb'].each { |f| load f }
+end
+
+task :default => :test
+
+repo = ENV['GITHUB_REPO'] || 'rstacruz/sinatra-backbone'
+namespace :doc do
+  desc "Builds documentation"
+  task :build do
+    # github.com/rstacruz/reacco
+    system "reacco -a --api lib --github #{repo}"
+  end
+
+  desc "Uploads documentation"
+  task :deploy => :build do
+    # github.com/rstacruz/git-update-ghpages
+    system "git update-ghpages -i doc #{repo}"
+  end
+end
+
+task :doc => :'doc:build'

data/lib/sinatra/backbone.rb

@@ -0,0 +1,11 @@
+module Sinatra
+  module Backbone
+    def self.version
+      "0.1.0.rc1"
+    end
+
+  end
+
+  autoload :RestAPI,  "sinatra/restapi"
+  autoload :JstPages, "sinatra/jstpages"
+end

data/lib/sinatra/jstpages.rb

@@ -0,0 +1,196 @@
+# ## Sinatra::JstPages [module]
+# A Sinatra plugin that adds support for JST (JavaScript Server Templates).
+#
+# #### Basic usage
+# Register the `Sinatra::JstPages` plugin in your application, and use
+# `serve_jst`.  This example serves all JST files found in `/views/**/*.jst.*`
+# (where `/views` is your views directory as defined in Sinatra's
+# `settings.views`) as `http://localhost:4567/jst.js`.
+#
+#     require 'sinatra/jstpages'
+#
+#     class App < Sinatra::Base
+#       register Sinatra::JstPages
+#       serve_jst '/jst.js'
+#     end
+#
+# You will need to link to the JST route in your layout. Make a `<script>` tag
+# where the `src='...'` attribute is the same path you provide to `serve_jst`.
+# 
+#     <script type='text/javascript' src='/jst.js'></script>
+#
+# So, if you have a JST view written in Jade, placed in `views/editor/edit.jst.jade`:
+#
+#     # views/editor/edit.jst.jade
+#     h1= "Edit "+name
+#       form
+#         button Save
+#
+# Now in your browser you may invoke `JST['templatename']`:
+#
+#     // Renders the editor/edit template
+#     JST['editor/edit']();
+#
+#     // Renders the editor/edit template with template parameters
+#     JST['editor/edit']({name: 'Item Name'});
+#
+# #### Using Sinatra-AssetPack?
+#
+# __TIP:__ If you're using the [sinatra-assetpack][sap] gem, just add `/jst.js`
+# to a package.  (If you're not using Sinatra AssetPack yet, you probably
+# should.)
+#
+# [sap]: http://ricostacruz.com/sinatra-assetpack
+#
+# #### Supported templates
+# Currently supports the following templates:
+#
+# * [Jade][jade] (`.jst.jade`) -- Jade templates. This requires
+# [jade.js][jade]. For older browsers, you will also need [json2.js][json2],
+# and an implementation of [String.prototype.trim][trim].
+#
+# * [Underscore templates][under_tpl] (`.jst.tpl`) -- Simple templates by
+# underscore. This requires [underscore.js][under], which Backbone also
+# requires.
+#
+# * [Haml.js][haml] (`.jst.haml`) -- A JavaScript implementation of Haml.
+# Requires [haml.js][haml].
+#
+# * [Eco][eco] (`.jst.eco`) -- Embedded CoffeeScript templates. Requires
+# [eco.js][eco] and [coffee-script.js][cs].
+#
+# [jade]: http://github.com/visionmedia/jade
+# [json2]: https://github.com/douglascrockford/JSON-js
+# [trim]: http://snippets.dzone.com/posts/show/701
+# [under_tpl]: http://documentcloud.github.com/underscore/#template
+# [under]: http://documentcloud.github.com/underscore
+# [haml]: https://github.com/creationix/haml-js
+# [eco]: https://github.com/sstephenson/eco
+# [cs]: http://coffeescript.org
+#
+module Sinatra
+  module JstPages
+    def self.registered(app)
+      app.extend ClassMethods
+      app.helpers Helpers
+    end
+
+    # Returns a hash to determine which engine is mapped onto a given extension.
+    def self.mappings
+      @mappings ||= Hash.new
+    end
+
+    def self.register(ext, engine)
+      mappings[ext] = engine
+    end
+
+    module Helpers
+      # Returns a list of JST files.
+      def jst_files
+        # Tuples of [ name, Engine instance ]
+        tuples = Dir.chdir(settings.views) {
+          Dir["**/*.jst.*"].map { |fn|
+            fn       =~ %r{^(.*)\.jst\.([^\.]+)$}
+            name, ext = $1, $2
+            engine    = JstPages.mappings[ext]
+
+            [ name, engine.new(File.join(settings.views, fn)) ]  if engine
+          }.compact
+        }
+
+        Hash[*tuples.flatten]
+      end
+    end
+
+    module ClassMethods
+      # ### serve_jst(path, [options]) [class method]
+      # Serves JST files in given `path`.
+      #
+      def serve_jst(path, options={})
+        get path do
+          content_type :js
+          jsts = jst_files.map { |(name, engine)|
+            %{
+              JST[#{name.inspect}] = function() {
+                if (!c[#{name.inspect}]) c[#{name.inspect}] = (#{engine.function});
+                return c[#{name.inspect}].apply(this, arguments);
+              };
+          }.strip.gsub(/^ {12}/, '')
+          }
+
+          %{
+            (function(){
+              var c = {};
+              if (!window.JST) window.JST = {};
+              #{jsts.join("\n  ")}
+            })();
+          }.strip.gsub(/^ {12}/, '')
+        end
+      end
+    end
+  end
+end
+
+
+# ## Sinatra::JstPages::Engine [class]
+# A template engine.
+#
+# #### Adding support for new template engines
+# You will need to subclass `Engine`, override at least the `function` method,
+# then use `JstPages.register`.
+#
+# This example will register `.jst.my` files to a new engine that uses
+# `My.compile`.
+#
+#     module Sinatra::JstPages
+#       class MyEngine < Engine
+#         def function() "My.compile(%s)"; end
+#       end
+#
+#       register 'my', MyEngine
+#     end
+#
+module Sinatra::JstPages
+  class Engine
+    # ### file [attribute]
+    # The string path of the template file.
+    attr_reader :file
+    def initialize(file)
+      @file = file
+    end
+
+    # ### contents [method]
+    # Returns the contents of the template file as a string.
+    def contents
+      File.read(@file)
+    end
+
+    # ### function [method]
+    # The JavaScript function to invoke on the precompile'd object.
+    #
+    # What this returns should, in JavaScript, return a function that can be
+    # called with an object hash of the params to be passed onto the template.
+    def function
+      "_.template(#{contents.inspect})"
+    end
+  end
+
+  class HamlEngine < Engine
+    def function() "Haml.compile(#{contents.inspect})"; end
+  end
+
+  class JadeEngine < Engine
+    def function() "require('jade').compile(#{contents.inspect})"; end
+  end
+
+  class EcoEngine < Engine
+    def function
+      "function() { var a = arguments.slice(); a.unshift(#{contents.inspect}); return eco.compile.apply(eco, a); }"
+    end
+  end
+
+  register 'tpl', Engine
+  register 'jade', JadeEngine
+  register 'haml', HamlEngine
+  register 'eco', EcoEngine
+end

data/lib/sinatra/restapi.rb

@@ -0,0 +1,202 @@
+require 'json'
+
+# ## Sinatra::RestAPI [module]
+# A plugin for providing rest API to models. Great for Backbone.js.
+#
+# To use this, simply `register` it to your Sinatra Application.  You can then
+# use `rest_create` and `rest_resource` to create your routes.
+#
+#     require 'sinatra/restapi'
+#
+#     class App < Sinatra::Base
+#       register Sinatra::RestAPI
+#     end
+#
+module Sinatra::RestAPI
+  def self.registered(app)
+    app.helpers Helpers
+  end
+
+  # ### rest_create(path, &block) [method]
+  # Creates a *create* route on the given `path`.
+  #
+  # This creates a `POST` route in */documents* that accepts JSON data.
+  # This route will return the created object as JSON.
+  #
+  # When getting a request, it does the following:
+  # 
+  #  * A new object is created by *yielding* the block you give. (Let's
+  #    call it `object`.)
+  #
+  #  * For each of the attributes, it uses the `attrib_name=` method in
+  #    your record. For instance, for an attrib like `title`, it wil lbe
+  #    calling `object.title = "hello"`.
+  #
+  #  * `object.save` will be called.
+  #
+  #  * `object`'s contents will then be returned to the client as JSON.
+  #
+  # See the example.
+  #
+  #     class App < Sinatra::Base
+  #       rest_create "/documents" do
+  #         Document.new
+  #       end
+  #     end
+  #
+  def rest_create(path, options={}, &blk)
+    # Create
+    post path do
+      @object = yield
+      rest_params.each { |k, v| @object.send :"#{k}=", v }
+      @object.save
+      rest_respond @object.to_hash
+    end
+  end
+
+  # ### rest_resource(path, &block) [method]
+  # Creates a *get*, *edit* and *delete* route on the given `path`.
+  #
+  # The block given will be yielded to do a record lookup. If the block returns
+  # `nil`, RestAPI will return a *404*.
+  #
+  # In the example, it creates routes for `/document/:id` to accept HTTP *GET*
+  # (for object retrieval), *PUT* (for editing), and *DELETE* (for destroying).
+  #
+  # Your model needs to implement the following methods:
+  #
+  #    * `save` (called on edit)
+  #    * `destroy` (called on delete)
+  #    * `<attrib_name_here>=` (called for each of the attributes on edit)
+  #
+  # If you only want to create routes for only one or two of the actions, you
+  # may individually use:
+  #
+  #    * `rest_get`
+  #    * `rest_edit`
+  #    * `rest_delete`
+  #
+  # All the methods above take the same arguments as `rest_resource`.
+  #
+  #     class App < Sinatra::Base
+  #       rest_resource "/document/:id" do
+  #         Document.find(id)
+  #       end
+  #     end
+  #
+  def rest_resource(path, options={}, &blk)
+    rest_get    path, options, &blk
+    rest_edit   path, options, &blk
+    rest_delete path, options, &blk
+  end
+
+  # ### rest_get(path, &block) [method]
+  # This is the same as `rest_resource`, but only handles *GET* requests.
+  #
+  def rest_get(path, options={}, &blk)
+    get path do |id|
+      @object = yield(id) or pass
+      rest_respond @object
+    end
+  end
+
+  # ### rest_edit(path, &block) [method]
+  # This is the same as `rest_resource`, but only handles *PUT*/*POST* (edit)
+  # requests.
+  #
+  def rest_edit(path, options={}, &blk)
+    callback = Proc.new { |id|
+      @object = yield(id) or pass
+      rest_params.each { |k, v| @object.send :"#{k}=", v  unless k == 'id' }
+      @object.save
+      rest_respond @object
+    }
+
+    # Make it work with `Backbone.emulateHTTP` on.
+    put  path, &callback
+    post path, &callback
+  end
+
+  # ### rest_delete(path, &block) [method]
+  # This is the same as `rest_resource`, but only handles *DELETE* (edit)
+  # requests. This uses `Model#destroy` on your model.
+  #
+  def rest_delete(path, options={}, &blk)
+    delete path do |id|
+      @object = yield(id) or pass
+      @object.destroy
+      rest_respond :result => :success
+    end
+  end
+
+  # ### JSON conversion
+  #
+  # The *create* and *get* routes all need to return objects as JSON. RestAPI
+  # attempts to convert your model instances to JSON by first trying
+  # `object.to_json` on it, then trying `object.to_hash.to_json`.
+  #
+  # It's recommended you implement `#to_hash` in your models.
+
+  # ### Helper methods
+  # There are some helper methods that are used internally be `RestAPI`,
+  # but you can use them too if you need them.
+  #
+  module Helpers
+    # #### rest_respond(object)
+    # Responds with a request with the given `object`.
+    #
+    # This will convert that object to either JSON or XML as needed, depending
+    # on the client's preferred type (dictated by the HTTP *Accepts* header).
+    #
+    def rest_respond(obj)
+      case request.preferred_type('*/json', '*/xml')
+      when '*/json'
+        content_type :json
+        rest_convert_to_json obj
+
+      else
+        pass
+      end
+    end
+
+    # #### rest_params
+    # Returns the object from the request.
+    #
+    # If the client sent `application/json` (or `text/json`) as the content
+    # type, it tries to parse the request body as JSON.
+    #
+    # If the client sent a standard URL-encoded POST with a `model` key
+    # (happens when Backbone uses `Backbone.emulateJSON = true`), it tries
+    # to parse it's key as JSON.
+    #
+    # Otherwise, the params will be returned as is.
+    #
+    def rest_params
+      if File.fnmatch('*/json', request.content_type)
+        JSON.parse request.body.read
+
+      elsif params['model']
+        # Account for Backbone.emulateJSON.
+        JSON.parse params['model']
+
+      else
+        params
+      end
+    end
+
+    def rest_convert_to_json(obj)
+      # Convert to JSON. This will almost always work as the JSON lib adds
+      # #to_json to everything.
+      json = obj.to_json
+
+      # The default to_json of objects is to JSONify the #to_s of an object,
+      # which defaults to #inspect. We don't want that.
+      return json  unless json[0..2] == '"#<'
+
+      # Let's hope they redefined to_hash.
+      return obj.to_hash.to_json  if obj.respond_to?(:to_hash)
+
+      raise "Can't convert object to JSON"
+    end
+  end
+end

data/sinatra-backbone.gemspec

@@ -0,0 +1,18 @@
+require './lib/sinatra/backbone'
+Gem::Specification.new do |s|
+  s.name = "sinatra-backbone"
+  s.version = Sinatra::Backbone.version
+  s.summary = "Helpful stuff using Sinatra with Backbone."
+  s.description = "Provides Rest API access to your models and serves JST pages."
+  s.authors = ["Rico Sta. Cruz"]
+  s.email = ["rico@sinefunc.com"]
+  s.homepage = "http://github.com/rstacruz/sinatra-backbone"
+  s.files = `git ls-files`.strip.split("\n")
+  s.executables = Dir["bin/*"].map { |f| File.basename(f) }
+
+  s.add_dependency "sinatra"
+  s.add_development_dependency "sequel", ">= 3.25.0"
+  s.add_development_dependency "sqlite3", ">= 1.3.4"
+  s.add_development_dependency "contest"
+  s.add_development_dependency "rack-test"
+end

data/test/app/views/chrome.jst.tpl

@@ -0,0 +1 @@
+<%= chrome %>

data/test/app/views/editor/edit.jst.jade

@@ -0,0 +1,2 @@
+h1
+  | Hello

data/test/app_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../test_helper', __FILE__)
+
+DB.create_table :books do
+  primary_key :id
+  String :name
+  String :author
+end
+
+class Book < Sequel::Model
+  def to_hash
+    { :name => name, :author => author }
+  end
+end
+
+class AppTest < UnitTest
+  class App < Sinatra::Base
+    register Sinatra::RestAPI
+    disable :show_exceptions
+    enable :raise_errors
+    rest_resource("/book/:id") { |id| Book[id] }
+  end
+  def app() App; end
+
+  describe "Sinatra::RestAPI" do
+    setup do
+      @book = Book.new
+      @book.name   = "Darkly Dreaming Dexter"
+      @book.author = "Jeff Lindsay"
+      @book.save
+      header 'Accept', 'application/json, */*'
+    end
+
+    teardown do
+      @book.destroy  if Book[@book.id]
+    end
+
+    test "should work properly" do
+      get "/book/#{@book.id}"
+
+      assert json_response['name']   == @book.name
+      assert json_response['author'] == @book.author
+    end
+
+    test "should 404" do
+      get "/book/823978"
+
+      assert last_response.status == 404
+    end
+  end
+end

data/test/jst_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class JstTest < UnitTest
+  class App < Sinatra::Base
+    register Sinatra::JstPages
+    disable :show_exceptions
+    enable :raise_errors
+
+    set :views, File.expand_path('../app/views', __FILE__)
+    serve_jst '/jst.js'
+  end
+  def app() App; end
+
+  test "jst" do
+    get '/jst.js'
+    body = last_response.body
+
+    assert body.include? 'window.JST'
+
+    assert body.include? '["editor/edit"]'
+    assert body.include? "Hello"
+
+    assert body.include? '["chrome"]'
+    assert body.include? "chrome"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'contest'
+require 'sinatra/base'
+require 'sequel'
+require 'rack/test'
+require 'json'
+require 'sinatra/backbone'
+
+class UnitTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def json_response
+    JSON.parse last_response.body
+  end
+end
+
+DB = Sequel.connect('sqlite::memory:')

data/test/to_json_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../test_helper', __FILE__)
+
+DB.create_table :albums do
+  primary_key :id
+  String :title
+  String :artist
+end
+
+class Album < Sequel::Model
+  def to_json
+    "X"
+  end
+
+  def to_hash
+    { :name => name, :author => author }
+  end
+
+  def to_xml
+    "lol"
+  end
+end
+
+class ToJsonTest < UnitTest
+  class App < Sinatra::Base
+    register Sinatra::RestAPI
+    disable :show_exceptions
+    enable :raise_errors
+    rest_resource("/album/:id") { |id| Album[id] }
+  end
+  def app() App; end
+
+  setup do
+    @album = Album.new
+    @album.title  = "Tanto Tempo"
+    @album.artist = "Bebel Gilberto"
+    @album.save
+    header 'Accept', 'application/json, */*'
+  end
+
+  test "use to_json" do
+    get "/album/#{@album.id}"
+    assert last_response.body == @album.to_json
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-backbone
+version: !ruby/object:Gem::Version
+  version: 0.1.0.rc1
+  prerelease: 6
+platform: ruby
+authors:
+- Rico Sta. Cruz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-12 00:00:00.000000000 +08:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &2161564340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161564340
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &2161563580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.25.0
+  type: :development
+  prerelease: false
+  version_requirements: *2161563580
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2161562920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.4
+  type: :development
+  prerelease: false
+  version_requirements: *2161562920
+- !ruby/object:Gem::Dependency
+  name: contest
+  requirement: &2161562440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161562440
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &2161561800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161561800
+description: Provides Rest API access to your models and serves JST pages.
+email:
+- rico@sinefunc.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- HISTORY.md
+- README.md
+- Rakefile
+- lib/sinatra/backbone.rb
+- lib/sinatra/jstpages.rb
+- lib/sinatra/restapi.rb
+- sinatra-backbone.gemspec
+- test/app/views/chrome.jst.tpl
+- test/app/views/editor/edit.jst.jade
+- test/app_test.rb
+- test/jst_test.rb
+- test/test_helper.rb
+- test/to_json_test.rb
+has_rdoc: true
+homepage: http://github.com/rstacruz/sinatra-backbone
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Helpful stuff using Sinatra with Backbone.
+test_files: []