service_crud 0.0.1

data/README.markdown

@@ -0,0 +1,106 @@
+# Service Crud
+
+The `service_crud` gem: A simple mixin for adding crud actions for a RESTful, ActiveResource style service (xml and json).
+
+## Requirements
+
+This gem works with Rails 3.
+
+## Installation
+
+    $ cd /path/to/your/rails3/app
+    $ echo "gem service_crud" >> Gemfile
+    $ bundle install
+
+## Usage
+
+Let's suppose we have a "Book" model, and we want to create XML and JSON RESTful services for it. Simple: 
+
+First, go to your routes.rb file and add the following route:
+  
+    resources :books
+
+Next, create the following controller in RAILS_ROOT/app/books_controller.rb:
+
+    class BooksController
+      include ServiceCrud
+    end
+
+That's it. You can now GET, POST, PUT, and DELETE books through the standard RESTful urls.
+
+## Callbacks
+
+Sometimes you need to do a little extra work on your data before/after you create/update/destroy. And sometimes that can't be pushed down to the ORM layer. 
+For example, suppose we want to set the `:updated_by` property on our model to the `current_user`. We could simply: 
+
+  class BooksController
+    include ServiceCrud
+    before_update :set_updated_by
+
+    private
+    def set_updated_by(model)
+      model.update_by = current_user
+    end
+  end
+
+ServiceCrud supports the following callbacks: `before_create`, `after_create`, `before_update`, `after_update`, `before_destroy`, and `after_destroy`. 
+
+## Model Guessing
+
+The `service_crud` library will look at the controller name and try to guess the model (e.g., "BooksController" -> "Book").
+
+If your controller name doesn't match your model, call the `model` method:
+
+    class MyBooksController
+      include ServiceCrud
+      model Book
+    end
+
+## PUT/POST parameter guessing
+
+Similarly, on POST or PUT, `service_crud` assumes that the top-level node of the XML or JSON is the lowercased, underscored, singularized symbol of your model name. 
+
+If that's not the case for your service, call the `model_attribute_root` class method: 
+
+    class BooksController
+      include ServiceCrud
+      model_attribute_root :my_book
+    end
+
+## ORM
+
+The `service_crud` library assumes an ActiveRecord ORM by default. It also, out of the box, supports the `couchrest_model` ORM for couchdb. 
+To use `couchrest_model`, simply:
+
+    class BooksController
+      include ServiceCrud
+      orm_methods! ServiceCrud::CouchRest::Model
+    end
+
+The default ORM methods are:
+    
+    module ServiceCrud
+      module DefaultOrm
+        def all; :all; end
+        def new; :new; end
+        def find; :find; end
+        def destroy; :destroy; end
+        def update_attributes; :update_attributes; end
+        def save; :save; end
+      end
+    end
+
+If you're using an ORM other than ActiveRecord or CouchRest::Model, and some or all of your ORM's method names differ from ActiveRecord's,
+then simply create a module that redefines one or more DefaultOrm methods. For example, suppose we create our own ORM, `MoonOrm`, and our method for finding 
+records is `lookup` instead of `find`. Then we'd simply:
+
+    module MoonOrmMethods
+      def find; :lookup; end
+    end
+
+Then, in our controller:
+    
+    class BooksController
+      include ServiceCrud
+      orm_methods! MoonOrmMethods
+    end

data/lib/service_crud/couchrest_model.rb

@@ -0,0 +1,7 @@
+module ServiceCrud
+  module CouchRest
+    module Model
+      def find; :get; end
+    end
+  end
+end

data/lib/service_crud/default_orm.rb

@@ -0,0 +1,10 @@
+module ServiceCrud
+  class DefaultOrm
+    def all; :all; end
+    def new; :new; end
+    def find; :find; end
+    def destroy; :destroy; end
+    def update_attributes; :update_attributes; end
+    def save; :save; end
+  end
+end

data/lib/service_crud/service_crud.rb

@@ -0,0 +1,153 @@
+module ServiceCrud
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def model(klass=nil)
+      @model ||= klass
+      @model || self.to_s.gsub("Controller", "").singularize.constantize
+    end
+
+    def model_attribute_root(root=nil)
+      @model_attribute_root ||= root
+      @model_attribute_root || self.model.to_s.underscore.to_sym
+    end
+
+    def orm_methods!(orm_module)
+      self.orm_methods.extend orm_module
+    end
+
+    def orm_methods
+      @orm_methods ||= ServiceCrud::DefaultOrm.new
+    end
+    
+    def before_create(method=nil, &block)
+      self.before_creates << method if method
+      self.before_creates << block if block 
+    end
+   
+    def before_update(method=nil, &block)
+      self.before_updates << method if method
+      self.before_updates << block if block 
+    end
+
+    def before_destroy(method=nil, &block)
+      self.before_destroys << method if method
+      self.before_destroys << block if block 
+    end
+
+    def after_create(method=nil, &block)
+      self.after_creates << method if method
+      self.after_creates << block if block 
+    end
+    
+    def after_update(method=nil, &block)
+      self.after_updates << method if method
+      self.after_updates << block if block 
+    end
+
+    def after_destroy(method=nil, &block)
+      self.after_destroys << method if method
+      self.after_destroys << block if block 
+    end
+
+    def before_creates;   @before_creates  ||= []; end 
+    def before_updates;   @before_updates  ||= []; end
+    def before_destroys;  @before_destroys ||= []; end
+    def after_creates;    @after_creates   ||= []; end 
+    def after_updates;    @after_updates   ||= []; end
+    def after_destroys;   @after_destroys  ||= []; end
+ 
+  end
+
+  # GET /your_model.xml
+  # GET /your_model.json
+  def index
+    @models = self.class.model.send self.class.orm_methods.all
+
+    respond_to do |format|
+      format.xml  { render :xml => @models }
+      format.json { render :json => @models }
+    end
+  end
+
+  # GET /your_model/1.xml
+  # GET /your_model/1.json
+  def show
+    @model = self.class.model.send self.class.orm_methods.find, params[:id] 
+
+    respond_to do |format|
+      format.xml  { render :xml => @model }
+      format.json { render :json => @model }
+    end
+  end
+
+  # POST /your_model.xml
+  # POST /your_model.json
+  def create
+    @model = self.class.model.send self.class.orm_methods.new, params[self.class.model_attribute_root] 
+    run_service_crud_before_callbacks @model
+
+    respond_to do |format|
+      if @model.send self.class.orm_methods.save
+        run_service_crud_after_callbacks @model
+        location = "/#{controller_name}/#{@model.id}"
+        format.xml  { render :xml => @model, :status => :created, :location => location }
+        format.json { render :json => @model, :status => :created, :location => location }
+      else
+        format.xml  { render :xml => @model.errors, :status => :unprocessable_entity }
+        format.json { render :json => {:errors => @model.errors.to_a}.to_json, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /your_model/1.xml
+  # PUT /your_model/1.json
+  def update
+    @model = self.class.model.send self.class.orm_methods.find, params[:id] 
+    run_service_crud_before_callbacks @model
+
+    respond_to do |format|
+      if @model.send self.class.orm_methods.update_attributes, params[self.class.model_attribute_root]
+        run_service_crud_after_callbacks @model
+        format.xml  { head :ok }
+        format.json { head :ok }
+      else
+        format.xml  { render :xml  => @model.errors, :status => :unprocessable_entity }
+        format.json { render :json => {:errors => @model.errors.to_a}.to_json, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /your_model/1.xml
+  # DELETE /your_model/1.json
+  def destroy
+    @model = self.class.model.send self.class.orm_methods.find, params[:id]
+    run_service_crud_before_callbacks @model
+    @model.send self.class.orm_methods.destroy
+    run_service_crud_after_callbacks @model
+ 
+    respond_to do |format|
+      format.xml  { head :ok }
+      format.json { head :ok }
+    end
+  end
+
+  private
+  def run_service_crud_before_callbacks(model)
+    run_service_crud_callbacks self.class.send("before_#{action_name}s".to_sym), model
+  end
+
+  def run_service_crud_after_callbacks(model)
+    run_service_crud_callbacks self.class.send("after_#{action_name}s".to_sym), model
+  end
+
+  def run_service_crud_callbacks(service_crud_callbacks, model)
+    service_crud_callbacks.each do |method|
+      method.call(model) if method.respond_to?(:call) # if it's a proc
+      self.send method, model if method.kind_of?(Symbol)
+    end
+  end
+end

data/lib/service_crud.rb

@@ -0,0 +1,3 @@
+require 'service_crud/default_orm'
+require 'service_crud/couchrest_model'
+require 'service_crud/service_crud'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: service_crud
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Matt Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-07 00:00:00 -04: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 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+description: A simple mixin for providing crud actions for a RESTful, ActiveResource style service (xml and json).
+email: moonmaster9000@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- lib/service_crud.rb
+- lib/service_crud/couchrest_model.rb
+- lib/service_crud/default_orm.rb
+- lib/service_crud/service_crud.rb
+has_rdoc: true
+homepage: http://github.com/moonmaster9000/service_crud
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: DRY service crud.
+test_files: []
+