bulk_api 0.0.1

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "sqlite3"
+
+gem "rspec-rails"
+gem "rack-test"
+
+gem "generator_spec"
+
+# To use debugger (ruby-debug for Ruby 1.8.7+, ruby-debug19 for Ruby 1.9.2+)
+# gem 'ruby-debug'
+# gem 'ruby-debug19'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2010 Strobe Inc.
+
+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.markdown

@@ -0,0 +1,319 @@
+# Bulk Rails API
+
+Bulk Rails API plugin makes integrating Sproutcore applications with Rails applications dead simple. It handles all the communication and allows to take advantage of bulk operations, which can make your application much faster. To use that plugin you will also need BulkDataSource, which will handle Sproutcore side of communcation.
+
+## Installing:
+
+### Rails app:
+
+Add this line to Gemfile and run bundle install:
+
+```ruby
+gem 'bulk_api'
+```
+
+To set up Bulk API in your Rails app:
+
+```
+rails generate bulk:install
+```
+
+Now you need to configure it in your application. First thing to do is to use it with your store:
+
+```javascript
+YourApp = SC.Application.create({
+  store: SC.Store.create().from('SC.BulkDataSource')
+});
+```
+
+The last thing that you need to do is to set resource names for your models. BulkDataSource assumes that you have resourceName attribute set on your record. If you don't have such attributes, you can add it like that:
+
+```javascript
+Todos.Todo = SC.Record.extend({
+  resourceName: 'todo'
+})
+```
+
+## Usage
+
+By default Bulk Api plugin handles all of the models, in production you will probably want to filter it:
+
+```ruby
+# app/bulk/abstract_resource.rb
+class ApplicationResource < Bulk::Resource
+  resources :tasks, :projects
+end
+```
+
+If you don't have any specific needs like authentication or authorization, you're good to go with such simple configuration. In other cases you will need to do a bit more to integrate your application.
+
+Bulk API approach is a bit different than standard REST APIs that you're probably used to, thus it needs to be handled differently. The point of using bulk API is to cut the requests number - it can handle many records (and many types of records) with one request. If you want to read more about how the API looks from HTTP point of view, please scroll to "HTTP Api" section. For now let's focus on what you need to know to implement it in ruby.
+
+When using bulk api you can handle things on 3 levels:
+1) All records level
+2) Particular record type level
+3) Individual record level
+
+Let's see how to handle things on all of the 3 levels to add your own logic (like authentication or authorization).
+
+If some of your logic is common for all the record types, you can use ApplicationResource that lives in app/bulk/abstract_resource.rb. This is base class for all of the resources, just like ApplicationController is a base class for all of your controllers (this may not be true for some applications, but let's agree that's the most common scenario). To allow easy integration with application, you have access to several application objects in ApplicationResource and its subclasses:
+
+* session
+* controller
+* params
+
+The methods used for records manipulation are:
+
+* get
+* create
+* update
+* delete
+
+### Authentication callbacks
+
+There are 3 kind of authorization callbacks that you can use. Each of them represents differnet level of handling records:
+
+* authenticate(action) - that callback is executed before handling the request, if it returns false, the entire response gets 401 status
+* authenticate_records(action, klass) - this callback is run before handling each type of resource, if it returns false, `not_authenticated` error is added to all of the records from given resource type. The class of the resource is passed as an argument.
+* authenticate_record(action, record) - this callback is run for each of the records, if it returns false, `not_authenticated` error is added to the given record
+
+Let's see example usage of each of this callbacks types:
+
+```ruby
+class ApplicationResource < Bulk::Resource
+  # delegate all the things that we need from controller
+  delegate current_user, :can?, :to => :controller
+
+  def authenticate(action)
+    current_user.logged_in?
+  end
+
+  def authenticate_records(action, klass)
+  end
+
+  def authenticate_record(action, record)
+  end
+end
+```
+
+### Authorization callbacks
+
+Authorization callbacks are very similar to authentication
+callbacks. Notice that authorization callbacks will only be run when
+authentication callback succeeds.
+
+* authorize(action) - that callback is executed before handling the request, if it returns false, the entire response gets 403 status
+* authorize_records(action, klass) - this callback is run before handling each type of resource, if it returns false, 403 error is added to all of the records from given resource type. The class of the resource is passed as an argument.
+* authorize_record(action, record) - this callback is run for each of the records, if it returns false, 403 error is added to the given record
+
+Let's see example usage of each of this callbacks types.
+
+```ruby
+class ApplicationResource < Bulk::Resource
+  # delegate all the things that we need from controller
+  delegate current_user, :can?, :to => :controller
+
+  def authorize(action)
+    current_user.is_admin?
+  end
+
+  def authorize_records(action, klass)
+    # klass can be for example Project
+    if action == :update
+      can? :update, klass
+    end
+  end
+
+  def authorize_record(action, record)
+    can? action, record # action returns one of the 4 actions (get, create, update, delete),
+                        # so this will check if user can perform given type of action on
+                        # the record
+  end
+end
+```
+
+### Params filtering
+
+While preparing your API, you will probably need to filter parameters
+that user can set on your models. The easiest way to do it is to set
+params_accessible or params_protected callbacks:
+
+```ruby
+class ApplicationResource < Bulk::Resource
+  def params_accessible(klass)
+    { :tasks    => [:title, :done],
+                    :projects => [:name] }
+  end
+
+  # or:
+
+  def params_protected(klass)
+    { :tasks => [:created_at, :updated_at] }
+  end
+end
+```
+
+You can also set it for individual resource classes. In such case this
+will overwrite the one that's set in ApplicationResource.
+
+### Attributes filtering
+
+If you want to filter the attributes that are sent in a response, the
+easiest way to do it is to use standard Rails mechanism for that -
+override as_json method in your model:
+
+```ruby
+class MyModel < ActiveRecord::Base
+  def as_json(options={})
+    super(:only => [:email, :avatar], :include =>[:addresses])
+  end
+end
+```
+
+With some applications that's not enough, though. If you have several
+user roles, the chances are that you will need to differentiate
+responses based on user rights. In that case you can use as_json
+callback. Value returned from that callback will be passed to the
+record's as_json method:
+
+```ruby
+class ApplicationResource < Bulk::Resource
+  def as_json(record)
+    # return hash that will be passed to record's as_json
+    { :only => [:email] }
+  end
+end
+```
+
+You can also override that method in individual resource classes.
+
+### Specific resource classes
+
+Sometimes you may want to implement specific application logic to one of the resources. Or you don't want to end up with Switch Driven Development in one of you authenticate callbacs. In such cases, the easiest way to handle resource specific code is to create an ApplicationResouce subclass that you can use to override standard behavior. There is a generator to make things easy for you:
+
+```
+rails g bulk:resource task
+```
+
+This will create the following file:
+
+```ruby
+# app/bulk/task_resource.rb
+class TaskResource < ApplicationResource
+end
+```
+
+If you do nothing else, Rails will automatically return records by retrieving them using ActiveRecord. You can customize any of the default behavior by overriding methods on the resource class. As you already now the main methods that are used to fetch and modify records are: get, create, update, delete. Let's see how you can override those methods:
+
+```ruby
+# app/resources/task_resource.rb
+class TaskResource < Sproutcore::Resource
+
+  def get(ids)
+    # ids is an array with records that we need to fetch
+
+    collection = super(ids)
+
+    # collection is an instance of Bulk::Collection class that keeps
+    # fetched records, please check the rest of the README and the docs
+    # to see how you can manipulate records in collection
+    collection
+  end
+
+  def create(records)
+    # records is an array of hashes with data that will be used
+    # to create new records e.g.:
+    # [{:title => "First", :done => false, :_local_id => 1},
+    #  {:title => "", :done => true, :_local_id => 3}]
+    # _local_id is needed to identify the records in sproutcore
+    # application, since they do not have an id yet
+
+    collection = super(records)
+
+    collection
+  end
+
+  def update(records)
+    # records array is very similar to the array from create method,
+    # but this time we should get data with id, like:
+    # [{:id => 1, :title => "First (changed!)", :done => false},
+    #  {:id => 2, :title => ""}]
+
+    collection = super(records)
+
+    collection
+  end
+
+  def delete(ids)
+    # similarly to get method, we get array of ids to delete
+
+    collection = super(ids)
+
+    collection
+  end
+end
+```
+
+While overriding records you can use super to handle the actions with default behavior or reimplement them yourself. In latter case you just need to make sure that you properly construct collection.
+
+### Bulk::Collection
+
+Bulk::Collection is a container for records and is used to construct response from. It has a few handy methods to easily modify collection, for more please refer to documantation.
+
+```ruby
+collection = Bulk::Colection.new
+collection.set(1, record) # add record with identifier '1', identifier is then used while constructing response
+                          # most of the time it's id or _local_id (the latter one is mainly for create)
+
+collection.errors.set(1, :access_denied) # add error that will be passed to DataSource
+                                         # notice that these errors are not the same as validation errors,
+                                         # this is more general way to tell DataSource what's going on
+collection.delete(1, record) # remove the record
+```
+
+### Advanced usage
+
+If you want to change class or resource name that will be send, you can use resource_class and resource_name methods:
+
+```ruby
+class TaskResource < Sproutcore::Resource
+  resource_class Todo
+  resource_name 'todo'
+end
+```
+
+## Http Bulk API
+
+The point of using bulk API is to cut the requests number. Because of its nature it can't be handled efficiently using standard REST API. The bulk API is designed to handle many records and record types in one request. Let's look how does GET request can look like with bulk API;
+
+```
+POST /bulk/api
+{
+  'todos': [
+    {'title': "First todo", 'done': false, '_storeKey': '3'},
+    {'title': "Second todo", 'done': true, '_storeKey': '10'}
+  ],
+  'projects': [
+    {'name': "Sproutcore todolist", '_storeKey': '12'}
+  ]
+}
+```
+
+As you can see we POST some new items to our application. Rails application will then respond with list of created records:
+
+```
+{
+  'todos': [
+    {'id': 1, 'title': "First todo", 'done': false, '_storeKey': '3'}
+  ],
+  'projects': [
+    {'id': 1, 'name': "Sproutcore todolist", '_storeKey': '12'}
+  ]
+  'errors': {
+    'todos': {
+    }
+  }
+}
+```
+
+As you can see, all the records that were created have id attached now and there is additional attribute 'errors' that tells us what went wrong during validation.

data/Rakefile

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rake/rdoctask'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'BulkApi'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/app/controllers/bulk/api_controller.rb

@@ -0,0 +1,25 @@
+class Bulk::ApiController < ActionController::Base
+  def get
+    options = Bulk::Resource.get(self)
+    yield options if block_given?
+    render options
+  end
+
+  def create
+    options = Bulk::Resource.create(self)
+    yield options if block_given?
+    render options
+  end
+
+  def update
+    options = Bulk::Resource.update(self)
+    yield options if block_given?
+    render options
+  end
+
+  def delete
+    options = Bulk::Resource.delete(self)
+    yield options if block_given?
+    render options
+  end
+end

data/lib/bulk/abstract_collection.rb

@@ -0,0 +1,55 @@
+module Bulk
+  class AbstractCollection
+    include Enumerable
+
+    def initialize
+      @items = {}
+    end
+
+    # Clear items
+    def clear
+      items.clear
+    end
+
+    # Get record with given id
+    def get(id)
+      items[id.to_s]
+    end
+    alias_method :exists?, :get
+
+    # Set record for a given id
+    def set(id, item)
+      items[id.to_s] = item
+    end
+
+    # Remove record from collection
+    def delete(id)
+      items.delete(id.to_s)
+    end
+
+    # Get the collection length
+    def length
+      items.length
+    end
+
+    # Clear records on collection
+    def clear
+      items.clear
+    end
+
+    # Checks if collection is empty
+    def empty?
+      items.empty?
+    end
+
+    # Return items ids
+    def ids
+      items.keys
+    end
+
+    delegate :each, :to => :items
+
+    private
+    attr_reader :items
+  end
+end

data/lib/bulk/collection.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext/module/delegation'
+require 'bulk/abstract_collection'
+
+module Bulk
+  class Collection < AbstractCollection
+    class Error < Struct.new(:type, :data)
+      def to_hash
+        h = {:type => type}
+        h[:data] = data if data
+        h
+      end
+    end
+
+    class Errors < AbstractCollection
+      attr_reader :collection
+
+      def initialize(collection)
+        @collection = collection
+        super()
+      end
+
+      def set(id, error, data = nil)
+        super(id, Error.new(error, data))
+      end
+    end
+
+    # Returns errors for the records
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
+    def to_hash(name, options = {})
+      only_ids = options[:only_ids]
+      response = {}
+
+      each do |id, record|
+        next if errors.get(id)
+        response[name] ||= []
+        response[name] << (only_ids ? record.id : record.as_json(options[:as_json]) )
+      end
+
+      errors.each do |id, error|
+        response[:errors] ||= {name => {}}
+        response[:errors][name][id] = error.to_hash
+      end
+
+      response
+    end
+  end
+end

data/lib/bulk/engine.rb

@@ -0,0 +1,13 @@
+require 'bulk/routes'
+
+module Bulk
+  class Engine < Rails::Engine
+    initializer "do not include root in json" do
+      # TODO: handle that nicely
+      ActiveRecord::Base.include_root_in_json = false
+    end
+
+    config.paths.add "app/bulk", :eager_load => true
+    config.paths.add "app/sproutcore"
+  end
+end

data/lib/bulk/resource.rb

@@ -0,0 +1,277 @@
+module Bulk
+  class AuthenticationError < StandardError; end
+  class AuthorizationError < StandardError; end
+
+  class Resource
+
+    attr_reader :controller
+    delegate :session, :params, :to => :controller
+    delegate :resource_class, :to => "self.class"
+    @@resources = []
+
+    class << self
+      attr_writer :application_resource_class
+      attr_reader :abstract
+      alias_method :abstract?, :abstract
+
+      def resource_class(klass = nil)
+        @resource_class = klass if klass
+        @resource_class
+      end
+
+      def resource_name(name = nil)
+        @resource_name = name if name
+        @resource_name
+      end
+
+      def resources(*resources)
+        @@resources = resources unless resources.blank?
+        @@resources
+      end
+
+      def application_resource_class
+        @application_resource_class ||= ApplicationResource
+        @application_resource_class.is_a?(Class) ? @application_resource_class : Object.const_get(@application_resource_class.to_sym)
+      end
+
+      def inherited(base)
+        if base.name == application_resource_class.to_s
+          base.abstract!
+        elsif base.name =~ /(.*)Resource$/
+          base.resource_name($1.underscore.singularize)
+        end
+      end
+
+      %w/get create update delete/.each do |method|
+        define_method(method) do |controller|
+          handle_response(method, controller)
+        end
+      end
+
+      def abstract!
+        @abstract = true
+        @@resources = []
+      end
+      protected :abstract!
+
+      private
+
+      # TODO: refactor this to some kind of Response class
+      def handle_response(method, controller)
+        response = {}
+        application_resource = application_resource_class.new(controller, :abstract => true)
+
+        if application_resource.respond_to?(:authenticate)
+          raise AuthenticationError unless application_resource.authenticate(method)
+        end
+
+        if application_resource.respond_to?(:authorize)
+          raise AuthorizationError unless application_resource.authorize(method)
+        end
+
+        controller.params.each do |resource, hash|
+          next unless resources.blank? || resources.include?(resource.to_sym)
+          resource_object = instantiate_resource_class(controller, resource)
+          next unless resource_object
+          collection = resource_object.send(method, hash)
+          as_json = resource_object.send(:as_json, resource_object.send(:klass))
+          options = {:only_ids => (method == 'delete'), :as_json => as_json}
+          response.deep_merge! collection.to_hash(resource_object.plural_resource_name.to_sym, options)
+        end
+
+        { :json => response }
+      rescue AuthenticationError
+        { :status => 401 }
+      rescue AuthorizationError
+        { :status => 403 }
+      end
+
+      def instantiate_resource_class(controller, resource)
+        begin
+          "#{resource.to_s.singularize}_resource".classify.constantize.new(controller)
+        rescue NameError
+          begin
+            application_resource_class.new(controller, :resource_name => resource)
+          rescue NameError
+          end
+        end
+      end
+    end
+
+    def initialize(controller, options = {})
+      @controller = controller
+      @resource_name = options[:resource_name].to_s if options[:resource_name]
+
+      # try to get klass to raise error early if something is not ok
+      klass unless options[:abstract]
+    end
+
+    def get(ids = 'all')
+      all = ids.to_s == 'all'
+      collection = Collection.new
+      with_records_auth :get, collection, (all ? nil : ids) do
+        records = all ? klass.all : klass.where(:id => ids)
+        records.each do |r|
+          with_record_auth :get, collection, r.id, r do
+            collection.set(r.id, r)
+          end
+        end
+      end
+      collection
+    end
+
+    def create(hashes)
+      collection = Collection.new
+      ids = hashes.map { |r| r[:_local_id] }
+      with_records_auth :create, collection, ids do
+        hashes.each do |attrs|
+          local_id = attrs.delete(:_local_id)
+          record = klass.new(filter_params(attrs))
+          record[:_local_id] = local_id
+          with_record_auth :create, collection, local_id, record do
+            record.save
+            set_with_validity_check(collection, local_id, record)
+          end
+        end
+      end
+      collection
+    end
+
+    def update(hashes)
+      collection = Collection.new
+      ids = hashes.map { |r| r[:id] }
+      with_records_auth :update, collection, ids do
+        hashes.each do |attrs|
+          attrs.delete(:_local_id)
+          record = klass.where(:id => attrs[:id]).first
+          with_record_auth :update, collection, record.id, record do
+            record.update_attributes(filter_params(attrs))
+            set_with_validity_check(collection, record.id, record)
+          end
+        end
+      end
+      collection
+    end
+
+    def delete(ids)
+      collection = Collection.new
+      with_records_auth :delete, collection, ids do
+        ids.each do |id|
+          record = klass.where(:id => id).first
+          with_record_auth :delete, collection, record.id, record do
+            record.destroy
+            set_with_validity_check(collection, record.id, record)
+          end
+        end
+      end
+      collection
+    end
+
+    def plural_resource_name
+      resource_name.to_s.pluralize
+    end
+
+    def resource_name
+      @resource_name || self.class.resource_name
+    end
+
+    def as_json(klass)
+      {}
+    end
+
+    private
+    delegate :abstract?, :to => "self.class"
+
+    def with_record_auth(action, collection, id, record, &block)
+      with_record_authentication(action, collection, id, record) do
+        with_record_authorization(action, collection, id, record, &block)
+      end
+    end
+
+    def with_records_auth(action, collection, ids, &block)
+      with_records_authentication(action, collection, ids) do
+        with_records_authorization(action, collection, ids, &block)
+      end
+    end
+
+    def with_record_authentication(action, collection, id, record)
+      authenticated = self.respond_to?(:authenticate_record) ? authenticate_record(action, record) : true
+      if authenticated
+        yield
+      else
+        collection.errors.set(id, 'not_authenticated')
+      end
+    end
+
+    def with_record_authorization(action, collection, id, record)
+      authorized = self.respond_to?(:authorize_record) ? authorize_record(action, record) : true
+      if authorized
+        yield
+      else
+        collection.errors.set(id, 'forbidden')
+      end
+    end
+
+    def with_records_authentication(action, collection, ids)
+      authenticated = self.respond_to?(:authenticate_records) ? authenticate_records(action, klass) : true
+      if authenticated
+        yield
+      else
+        ids.each do |id|
+          collection.errors.set(id, 'not_authenticated')
+        end
+      end
+    end
+
+    def with_records_authorization(action, collection, ids)
+      authorized = self.respond_to?(:authorize_records) ? authorize_records(action, klass) : true
+      if authorized
+        yield
+      else
+        ids.each do |id|
+          collection.errors.set(id, 'forbidden')
+        end
+      end
+    end
+
+    def set_with_validity_check(collection, id, record)
+      collection.set(id, record)
+      unless record.errors.empty?
+        collection.errors.set(id, :invalid, record.errors.to_hash)
+      end
+    end
+
+    def filter_params(attributes)
+      if self.respond_to?(:params_accessible)
+        filter_params_for(:accessible, attributes)
+      elsif self.respond_to?(:params_protected)
+        filter_params_for(:protected, attributes)
+      else
+        attributes
+      end
+    end
+
+    def filter_params_for(type, attributes)
+      filter = send("params_#{type}", klass)
+      filter = filter ? filter[resource_name.to_sym] : nil
+
+      if filter
+        attributes.delete_if do |k, v|
+          delete_if = filter.include?(k)
+          type == :accessible ? !delete_if : delete_if
+        end
+      end
+
+      attributes
+    end
+
+    def klass
+      @_klass ||= begin
+        resource_class || (resource_name ? resource_name.to_s.singularize.classify.constantize : nil) ||
+          raise("Could not get resource class, please either set resource_class or resource_name that matches model that you want to use")
+      rescue NameError
+        raise NameError.new("Could not find class matching your resource_name (#{resource_name} - we were looking for #{resource_name.classify})")
+      end
+    end
+  end
+end

data/lib/bulk/routes.rb

@@ -0,0 +1,14 @@
+module ActionDispatch::Routing
+  module BulkHelpers
+    def bulk_routes(path)
+      get    path => "bulk/api#get"
+      post   path => "bulk/api#create"
+      put    path => "bulk/api#update"
+      delete path => "bulk/api#delete"
+    end
+  end
+
+  class Mapper
+    include BulkHelpers
+  end
+end

data/lib/bulk/sproutcore.rb

@@ -0,0 +1,19 @@
+require 'sproutcore'
+require 'sproutcore/rack/service'
+require 'sproutcore/models/project'
+
+module Bulk
+  class Sproutcore
+    def sproutcore
+      @sproutcore ||= begin
+        project = SC::Project.load Rails.application.paths["app/sproutcore"].first, :parent => SC.builtin_project
+        SC::Rack::Service.new(project)
+      end
+    end
+
+    def call(env)
+      env["PATH_INFO"] = "/" if env["PATH_INFO"].blank?
+      sproutcore.call(env)
+    end
+  end
+end

data/lib/bulk_api.rb

@@ -0,0 +1,5 @@
+module Bulk
+  require 'bulk/collection'
+  require 'bulk/resource'
+  require 'bulk/engine'
+end

data/lib/generators/bulk/install/install_generator.rb

@@ -0,0 +1,28 @@
+module Bulk
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      desc <<DESC
+Description:
+    Creates initializer with configuration and adds required routes
+DESC
+
+      def self.source_root
+        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      end
+
+      def routes_entry
+        route 'bulk_routes "/api/bulk"'
+        route 'mount Bulk::Sproutcore.new => "/_sproutcore"'
+      end
+
+      def copy_app_bulk_application_resource
+        template 'app/bulk/application_resource.rb'
+      end
+
+      def copy_initializers_bulk_api
+        template "config/initializers/bulk_api.rb"
+      end
+    end
+  end
+end

data/lib/generators/bulk/install/templates/app/bulk/application_resource.rb

@@ -0,0 +1,9 @@
+class ApplicationResource < Bulk::Resource
+  # In production you should filter resources that you want to handle.
+  # To do so, just uncomment the next line and set resources that should be
+  # available in Bulk API:
+  #
+  # resources :tasks, :projects
+
+end
+

data/lib/generators/bulk/install/templates/config/initializers/bulk_api.rb

@@ -0,0 +1,3 @@
+# If you want to use something other than ApplicationResource for your main class you can change it here, just uncomment the next line and change the class name:
+#
+# Bulk::Resource.application_resource_class = :ApplicationResource

data/lib/generators/bulk/resource/resource_generator.rb

@@ -0,0 +1,13 @@
+module Bulk
+  module Generators
+    class ResourceGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      check_class_collision :suffix => "Resource"
+
+      def generate_part_class
+        template "resource.rb", "app/bulk/#{file_name}_resource.rb"
+      end
+    end
+  end
+end

data/lib/generators/bulk/resource/templates/resource.rb

@@ -0,0 +1,2 @@
+class <%= class_name %>Resource < ApplicationResource
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: bulk_api
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Piotr Sarnacki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-08 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sproutcore
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.5"
+  type: :runtime
+  version_requirements: *id002
+description: Easy integration of rails apps with sproutcore.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- app/controllers/bulk/api_controller.rb
+- lib/bulk/abstract_collection.rb
+- lib/bulk/collection.rb
+- lib/bulk/engine.rb
+- lib/bulk/resource.rb
+- lib/bulk/routes.rb
+- lib/bulk/sproutcore.rb
+- lib/bulk_api.rb
+- lib/generators/bulk/install/install_generator.rb
+- lib/generators/bulk/install/templates/app/bulk/application_resource.rb
+- lib/generators/bulk/install/templates/config/initializers/bulk_api.rb
+- lib/generators/bulk/resource/resource_generator.rb
+- lib/generators/bulk/resource/templates/resource.rb
+- MIT-LICENSE
+- Rakefile
+- Gemfile
+- README.markdown
+has_rdoc: true
+homepage: 
+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: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Easy integration of rails apps with sproutcore.
+test_files: []
+