yodatra 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c28dec8ba275bce4a44a79d41f2c3aac9a265e5e
-  data.tar.gz: f516d481e2e6ad9ce2c49ab3805584f1e0bfa270
+  metadata.gz: e6ce8fae3026a73118bcc2345e60dc4e1e93eabc
+  data.tar.gz: d6f0c9ac4382981d4fd48d8baec3864ed3018f0d
 SHA512:
-  metadata.gz: bb2fb3841624fb4f869286779ed5c7a1b28e84165b8dca7f09cb3a577c7f01acb1f0fc851ceb143bef3d3ede66eff5b8a6a55d72aef1a07f8d4964b00e9f5a31
-  data.tar.gz: a97295b4414f0939ec2d9ad263ecfadd6b807a80130cfc5642f781a955fadc88e32867e4ef5da82418719b633f59aaefb4d5fae5124401bf37450e528f98ed71
+  metadata.gz: 9ee95b6a0f7cf1b024c9a07a55e4babcc2381c1d408be1d4cfa2a51250ab9aab93dcafaf4241587428c99f231f2168617e9c50001b701e09061a42168a54bab2
+  data.tar.gz: a593575a605d5d1f134ad7a4c72b219b73d46e946a2957132a82d4a245b133c7aa183feb1fb72b59c608fd2aa457deb55292a1478d2b5be346e15a89f6e6552e

data/README.md

@@ -6,4 +6,128 @@ Backend development you shall do. And yodatra you shall use.
 
 A minimalistic framework built on top of Sinatra it is.
 
-Visiting [https://squareteam.github.io/yodatra](https://squareteam.github.io/yodatra) will help you to control the force.
+The power of __ActiveRecord__ it gives you and the simplicity of a __Sinatra__ app. And all sort of small helpers.
+
+## Instantly deploy your API
+
+Based on your ActiveRecord models an API will be exposed very simply.
+For every resource you want to expose, you will need to create a controller that inherits from the ```Yodatra::ModelsController```.
+
+For example, given a `User` model
+```ruby
+class User < ActiveRecord::Base
+# Your model definition
+end
+```
+
+Creating a controller as simple as
+```ruby
+class UsersController < Yodatra::ModelsController
+  # limit read_scope
+  def read_scope
+    { only: [:id, :name] }
+  end
+
+  # whitelist assignable attributes
+  def user_params
+    params.permit(:name)
+  end
+end
+```
+will expose all these routes:
+
+```
+GET /users
+```
+
+> retrieves all users _(attributes exposed are limited by the `read_scope` method defined in the controller)_
+
+```
+GET /users/:id
+```
+
+> retrieves a user _(attributes exposed are limited by the `read_scope` method defined in the controller)_
+
+```
+POST /users
+```
+
+> creates a user _(attributes assignable are limited by the `user_params` method defined in the controller as advised here http://guides.rubyonrails.org/action_controller_overview.html#strong-parameters)_
+
+```
+PUT /users/:id
+```
+
+> updates a user _(attributes assignable are limited by the `user_params` method defined in the controller as advised here http://guides.rubyonrails.org/action_controller_overview.html#strong-parameters)_
+
+```
+DELETE /users/:id
+```
+
+> deletes a user
+
+
+If your model is referenced by another model (with a `has_many`, `has_one` or `belongs_to` relationship), nested routes are also created for you. And you don't need to worry about the references/joins, they are done automaticaly!
+
+For example, imagine a `Team` model that has many `User`s
+```ruby
+class Team < ActiveRecord::Base
+  has_many :users
+end
+```
+
+the following routes will be exposed by the `UsersController` controller:
+```
+GET /team/:team_id/users
+```
+```
+GET /team/:team_id/users/:id
+```
+```
+POST /team/:team_id/users
+```
+```
+PUT /team/:team_id/users/:id
+```
+```
+DESTROY /team/:team_id/users/:id
+```
+
+### Note
+You can disable __any__ of these actions by using the __::disable__ class method and providing the list of actions you want to disable
+```ruby
+class UsersController < Yodatra::ModelsController
+  disable :read, :update, :delete, :nested_read_all, :nested_delete
+end
+```
+
+### Extra
+You can enable a special "search" action by using the __::enable_search_on__ class method
+```ruby
+class UsersController < Yodatra::ModelsController
+  enable_search_on :name
+end
+```
+
+## What it also provides for free
+
+- __Logger__: Logs inside ```<your_project>/log``` in an environment named file ```env.err.log``` for all errors and ```env.log``` only for access logs.
+- __Boot__: loads automaticaly all ```<your_project>/app/models/**/*.rb``` files and ```<your_project>/app/controllers/**/*.rb``` files. Establish a connection with a database by reading the ```<your_project>/config/database.yml``` file 
+
+For that create a sinatra app that inherits from ```Yodatra::Base``` instead of ```Sinatra::Base```.
+
+## Other useful modules
+
+- __Throttling__: To fight against the dark side, an API throttling you will need. Example: allow only 10 requests/minute per IP: 
+```ruby
+use Yodatra::Throttle, {:redis_conf => {}, :rpm => 10}
+```
+_warning: this module requires redis_
+- __ApiFormatter__:  this middleware will help you to format all your replies. Example: wrap all you replies within a ```{data: <...>}``` object:
+```ruby
+use Yodatra::ApiFormatter do |status, headers, response|
+  body = response.empty? ? '' : response.first
+  response = [{:data => body}]
+  [status, headers, response]
+end
+```

data/Rakefile

@@ -1,5 +1,12 @@
 require 'rubygems'
 
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+end
+
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new do |task|
   task.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]

data/lib/yodatra/models_controller.rb

@@ -4,37 +4,46 @@ module Yodatra
   #
   # Simply create your controller that inherits from this class, keeping the naming convention.
   #
-  # For example, given a <b>User</b> model, creating a <b>class UsersController < Yodatra::ModelsController</b>, it will expose these routes:
-  # GET /users
-  #  => retrieves all users <i>(attributes exposed are limited by the <b>read_scope</b> method defined in the <b>UsersController</b>)</i>
+  # For example, given a `User` model, creating a `class UsersController < Yodatra::ModelsController`, it will expose these routes:
   #
-  # GET /users/:id
-  #  => retrieves a user <i>(attributes exposed are limited by the <b>read_scope</b> method defined in the <b>UsersController</b>)</i>
+  #  GET /users
+  # > retrieves all users _(attributes exposed are limited by the <b>read_scope</b> method defined in the <b>UsersController</b>)_
   #
-  # POST /users
-  #  => creates a user <i>(attributes assignable are limited by the <b>user_params</b> method defined in the <b>UsersController</b>)</i>
+  #  GET /users/:id
+  # > retrieves a user _(attributes exposed are limited by the `read_scope`` method defined in the `UsersController`)_
   #
-  # PUT /users/:id
-  #  => updates a user <i>(attributes assignable are limited by the <b>user_params</b> method defined in the <b>UsersController</b>)</i>
+  #  POST /users
+  # > creates a user _(attributes assignable are limited by the `user_params` method defined in the `UsersController`)_
   #
-  # DELETE /users/:id
-  #  => deletes a user
+  #  PUT /users/:id
+  # > updates a user _(attributes assignable are limited by the `user_params` method defined in the `UsersController`)_
+  #
+  #  DELETE /users/:id
+  # > deletes a user
   #
   # If your model is referenced by another model, nested routes are also created for you. And you don't need to worry about the references/joins, they are done automaticly!
-  # For example, imagine a <b>Team</b> model that has many <b>User</b>s, the following routes will be exposed:
-  # GET /team/:team_id/users, GET /team/:team_id/users/:id, POST /team/:team_id/users, PUT /team/:team_id/users/:id and DESTROY /team/:team_id/users/:id
+  # For example, imagine a `Team` model that has many `User`s, the following routes will be exposed:
+  #
+  #  GET /team/:team_id/users
+  #
+  #  GET /team/:team_id/users/:id
+  #
+  #  POST /team/:team_id/users
   #
-  # _Note_: You can disable any of these five actions by using the  `#disable` class method
-  #         and giving in parameters the list of actions you want to disable
-  #         e.g. `disable :read, :read_all, :create, :update, :delete`
+  #  PUT /team/:team_id/users/:id
   #
-  # _Note2_: You can enable a special "search" action by using the `#enable_search_on` class method
+  #  DESTROY /team/:team_id/users/:id
+  #
+  # === Note:
+  # You can disable any of these actions by using the __::disable__ class method
+  # and providing the list of actions you want to disable
+  #  disable :read, :read_all, :create, :update, :delete, :nested_read_all, :nested_delete
+  #
+  # === Extra:
+  # You can enable a special "search" action by using the __::enable_search_on__ class method
+  #  enable_search_on :name
   class ModelsController < Sinatra::Base
 
-    before do
-      content_type 'application/json'
-    end
-
     # Generic route to target ONE resource
     ONE_ROUTE =
         %r{\A/([\w]+?)/([0-9]+)(?:/([\w]+?)/([0-9]+)){0,1}\Z}
@@ -47,6 +56,10 @@ module Yodatra
     SEARCH_ROUTE =
       %r{\A/([\w]+?)(?:/([0-9]+)/([\w]+?)){0,1}/search\Z}
 
+    before do
+      content_type 'application/json'
+    end
+
     READ_ALL = :read_all
     get ALL_ROUTE do
       retrieve_resources READ_ALL do |resource|
@@ -65,13 +78,13 @@ module Yodatra
     post ALL_ROUTE do
       retrieve_resources CREATE_ONE do |resource|
         hash = self.send("#{model_name.underscore}_params".to_sym)
-        @one = resource.new hash
+        @one = resource.create hash
 
-        if @one.save
-          @one.as_json(read_scope).to_json
-        else
+        if @one.id.nil?
           status 400
           @one.errors.full_messages.to_json
+        else
+          @one.as_json(read_scope).to_json
         end
       end
     end
@@ -101,28 +114,6 @@ module Yodatra
       end
     end
 
-    # Defines a nested route or not and retrieves the correct resource (or resources)
-    # @param disables is the name to check if it was disabled
-    # @param &block to be yield with the retrieved resource
-    def retrieve_resources(disables)
-      pass unless involved?
-      no_route if disabled? disables
-
-      model = model_name.constantize
-      nested = nested_resources if nested?
-
-      if model.nil? || nested.nil? && nested?
-        raise ActiveRecord::RecordNotFound
-      else
-        model = nested if nested?
-        one_id = nested? ? params[:captures].fourth : params[:captures].second if params[:captures].length == 4
-        model = model.find one_id unless one_id.nil?
-        yield(model)
-      end
-    rescue ActiveRecord::RecordNotFound
-      record_not_found
-    end
-
     class << self
       def model_name
         self.name.split('::').last.gsub(/sController/, '')
@@ -143,6 +134,11 @@ module Yodatra
         end
       end
 
+      # This class method enables the search routes `/resoures/search?q=search+terms` for the model.
+      # The search will be performed on all the attributes given in parameter of this method.
+      # E.g. if you enabled the search on `:name` and `:email` attrs
+      # a GET /resources/search?q=john+doe
+      # will return all `Resource` instance where the name or the email matches either "john" or "doe"
       def enable_search_on(*attributes)
         self.instance_eval do
           get SEARCH_ROUTE do
@@ -170,6 +166,28 @@ module Yodatra
 
     private
 
+    # Defines a nested route or not and retrieves the correct resource (or resources)
+    # @param disables is the name to check if it was disabled
+    # @param &block to be yield with the retrieved resource
+    def retrieve_resources(disables)
+      pass unless involved?
+      no_route if disabled? disables
+
+      model = model_name.constantize
+      nested = nested_resources if nested?
+
+      if model.nil? || nested.nil? && nested?
+        raise ActiveRecord::RecordNotFound
+      else
+        model = nested if nested?
+        one_id = nested? ? params[:captures].fourth : params[:captures].second if params[:captures].length == 4
+        model = model.find one_id unless one_id.nil?
+        yield(model)
+      end
+    rescue ActiveRecord::RecordNotFound
+      record_not_found
+    end
+
     def nested?
       params[:captures].length >= 3 && params[:captures].first(3).none?(&:nil?)
     end
@@ -207,7 +225,7 @@ module Yodatra
     end
 
     def involved?
-      !involved.match(/#{model_name.underscore}[s]?/).nil?
+      !involved.match(/\A#{model_name.underscore}[s]?\Z/).nil?
     end
 
     # read_scope defaults to all attrs of the model

data/lib/yodatra/version.rb

@@ -1,3 +1,3 @@
 module Yodatra
-  VERSION = '0.3.5'
+  VERSION = '0.3.6'
 end

data/spec/active_record/connection_adapters/fake_adapter.rb

@@ -35,9 +35,9 @@ module ActiveRecord
           options[:null])
       end
 
-      def columns(table_name, message)
+      def columns(table_name, message=nil)
         @columns[table_name]
       end
     end
   end
-end
+end

data/spec/data/model.rb

@@ -12,6 +12,7 @@ class Model
     end
     def create(param); me = self.new(param); me.save; me; end
   end
+  def id; ALL.index @data; end
   def initialize(param); @data = param[:data]; self; end
   def save
     unless @data.nil? || @data.match(/[\d]+/)

data/spec/unit/models_controller_spec.rb

@@ -39,6 +39,19 @@ describe 'Model controller' do
         expect(last_response).to_not be_ok
       end
     end
+    context 'when a bad route is requested' do
+      before do
+        class Yodatra::ModelsController
+          def read_all_disabled?; false; end
+        end
+      end
+      it 'fails with no route' do
+        get '/amodels'
+
+        expect(last_response).to_not be_ok
+        expect(last_response.body).to eq('<h1>Not Found</h1>')
+      end
+    end
   end
   describe 'getting an specific Model instance' do
     it 'should have a GET one route' do
@@ -70,6 +83,15 @@ describe 'Model controller' do
         expect(last_response).to be_ok
       end
     end
+    context 'on a nested object' do
+      it 'creates an instance, saves it and succeed' do
+        expect{
+          post '/models/1/models', {:data=> 'e'}
+        }.to change(Model::ALL, :length).by(1)
+
+        expect(last_response).to be_ok
+      end
+    end
     context 'with incorrect params' do
       it 'does not create an instance and fails' do
         expect{

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yodatra
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Paul Bonaud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-23 00:00:00.000000000 Z
+date: 2014-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack