sinatra-backbone-2 0.1.1

data/lib/sinatra/restapi.rb

@@ -0,0 +1,299 @@
+require 'json'
+
+# ## 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
+#
+# ### RestAPI example
+# Here's a simple example of how to use Backbone models with RestAPI.
+# Also see the [example application][ex] included in the gem.
+#
+# [ex]: https://github.com/rstacruz/sinatra-backbone/tree/master/examples/restapi
+#
+# #### Model setup
+# Let's say you have a `Book` model in your application. Let's use [Sequel][sq]
+# for this example, but feel free to use any other ORM that is
+# ActiveModel-compatible.
+#
+# You will need to define `to_hash` in your model.
+#
+#     db = Sequel.connect(...)
+#
+#     db.create_table :books do
+#       primary_key :id
+#       String :title
+#       String :author
+#     end
+#
+#     class Book < Sequel::Model
+#       # ...
+#       def to_hash
+#         { :title => title, :author => author, :id => id }
+#       end
+#     end
+#
+# [sq]: http://sequel.rubyforge.org
+#
+# #### Sinatra
+# To provide some routes for Backbone models, use `rest_resource` and
+# `rest_create`:
+#
+#     require 'sinatra/restapi'
+#
+#     class App < Sinatra::Base
+#       register Sinatra::RestAPI
+#
+#       rest_create '/book' do
+#         Book.new
+#       end
+#
+#       rest_resource '/book/:id' do |id|
+#         Book.find(:id => id)
+#       end
+#     end
+#
+# #### JavaScript
+# In your JavaScript files, let's make a corresponding model.
+#
+#     Book = Backbone.Model.extend({
+#       urlRoot: '/book'
+#     });
+#
+# Now you may create a new book through your JavaScript:
+#
+#     book = new Book;
+#     book.set({ title: "Darkly Dreaming Dexter", author: "Jeff Lindsay" });
+#     book.save();
+#
+#     // In Ruby, equivalent to:
+#     // book = Book.new
+#     // book.title  = "Darkly Dreaming Dexter"
+#     // book.author = "Jeff Lindsay"
+#     // book.save
+#
+# Or you may retrieve new items. Note that in this example, since we defined
+# `urlRoot()` but not `url()`, the model URL with default to `/[urlRoot]/[id]`.
+#
+#     book = new Book({ id: 1 });
+#     book.fetch();
+#
+#     // In Ruby, equivalent to:
+#     // Book.find(:id => 1)
+#
+# Deletes will work just like how you would expect it:
+#
+#     book.destroy();
+#
+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"`.
+  #
+  #  * if `object.valid?` returns false, it returns an error 400.
+  #
+  #  * `object.save` will then 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 }
+
+      return 400, @object.errors.to_json  unless @object.valid?
+
+      @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 |id|
+  #         Document.find(:id => 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 |*args|
+      @object = yield(*args) 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 { |*args|
+      @object = yield(*args) or pass
+      rest_params.each { |k, v| @object.send :"#{k}=", v  unless k == 'id' }
+
+      return 400, @object.errors.to_json  unless @object.valid?
+
+      @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 |*args|
+      @object = yield(*args) 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`.
+  #
+  # You will need to implement `#to_hash` or `#to_json` in your models.
+  #
+  #     class Album < Sequel::Model
+  #       def to_hash
+  #         { :id     => id,
+  #           :title  => title,
+  #           :artist => artist,
+  #           :year   => year }
+  #       end
+  #     end
+
+  # ### 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 its value 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. Consider implementing #to_hash to #{obj.class.name}."
+    end
+  end
+end

data/sinatra-backbone.gemspec

@@ -0,0 +1,20 @@
+require './lib/sinatra/backbone'
+Gem::Specification.new do |s|
+  s.name = "sinatra-backbone-2"
+  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 "rake"
+  s.add_development_dependency "sequel", ">= 3.25.0"
+  s.add_development_dependency "sqlite3", "~> 1.3.4"
+  s.add_development_dependency "contest", "~> 0.1.3"
+  s.add_development_dependency "mocha", "~> 0.13.3"
+  s.add_development_dependency "rack-test", "~> 0.6.2"
+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,62 @@
+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
+
+  def validate
+    super
+    errors.add(:author, "can't be empty")  if author.to_s.size == 0
+  end
+end
+
+class AppTest < UnitTest
+  class App < Sinatra::Base
+    register Sinatra::RestAPI
+    disable :show_exceptions
+    enable :raise_errors
+    rest_create("/book") { Book.new }
+    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 "validation fail" do
+      hash = { :name => "The Claiming of Sleeping Beauty" }
+      post "/book", :model => hash.to_json
+      assert last_response.status != 200
+    end
+
+    test "should 404" do
+      get "/book/823978"
+
+      assert last_response.status == 404
+    end
+  end
+end

data/test/arity_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class ArityTest < UnitTest
+  class FauxModel
+    def initialize(stuff)
+      @stuff = stuff
+    end
+
+    def to_hash
+      { :contents => @stuff }
+    end
+  end
+
+  class App < Sinatra::Base
+    register Sinatra::RestAPI
+    disable :show_exceptions
+    enable :raise_errors
+
+    rest_resource("/api/:x/:y/:z") { |x, y, z| FauxModel.new ["Hello", x.to_i+1, y.to_i+1, z.to_i+1] }
+  end
+
+  def app() App; end
+
+  describe "Multi args support" do
+    test "get" do
+      header 'Accept', 'application/json, */*'
+      get "/api/20/40/60"
+
+      assert json_response["contents"] = ["Hello", 21, 41, 61]
+    end
+
+    test "put/post" do
+      FauxModel.any_instance.expects(:x=).times(1).returns(true)
+      FauxModel.any_instance.expects(:valid?).times(1).returns(true)
+      FauxModel.any_instance.expects(:save).times(1).returns(true)
+
+      header 'Accept', 'application/json, */*'
+      header 'Content-Type', 'application/json'
+      post "/api/20/40/60", JSON.generate('x' => 2)
+
+      assert json_response["contents"] = ["Hello", 21, 41, 61]
+    end
+  end
+end

data/test/emulate_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'ostruct'
+
+class EmulateTest < UnitTest
+  class App < Sinatra::Base
+    register Sinatra::RestAPI
+    disable :show_exceptions
+    enable :raise_errors
+
+    rest_resource("/api/:id") { |id| FauxModel.new }
+  end
+
+  def app() App; end
+
+  setup do
+    header 'Accept', 'application/json, */*'
+  end
+
+  test "emulate json and emulate http" do
+    FauxModel.any_instance.expects(:two=).times(1).returns(true)
+    FauxModel.any_instance.expects(:save).times(1).returns(true)
+    FauxModel.any_instance.expects(:valid?).times(1).returns(true)
+    FauxModel.any_instance.expects(:to_hash).times(1).returns('a' => 'b')
+
+    post "/api/2", :model => { :two => 2 }.to_json
+    assert json_response == { 'a' => 'b' }
+  end
+end
+
+class FauxModel
+end
+