json-crud-api 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79b2e0ca071a00b36b5255b2f4168b274e16f0bf
-  data.tar.gz: 767ca5c4018742511b7e539fcdf10fa0c34a2498
+  metadata.gz: 449673186265d26d910abcbee096846f98b417ae
+  data.tar.gz: 8c11a8db9c5a320fa0da8ba9d373dca3a8f073e3
 SHA512:
-  metadata.gz: 42c783872ea7f4e68a32d1d48f86a5baa960fa82a53f94045c8ca1c2099c51ea0448a9a02f7cb18bbbc63a6a8f492caff3621abd47538eb63c2167905d26458e
-  data.tar.gz: 64c631939a0817a09aae149993dd853a23e5d0fd302f4f4716c426f4a2eadf2eccaf94d767c6a2d200388cb65aca57cddb2a4c2fcc38a0f3041733ee74911887
+  metadata.gz: 2845c4c9df02675b8c0a178f5c1d1f3c4b73e775ead310bfb296ba8cff3e1b6f37aa05526644ad8da71547a0af4e56722fef515027608827cadb68810a981586
+  data.tar.gz: 97f9dd8748df1a814977e2193df3830d8a85bcc24ff3892c6ed9d8f270b8c3b0525f68347797943de34ceeeb8da267e2045f24cea6c677db741385abd403541f

data/lib/json-crud-api/api.rb

@@ -4,7 +4,10 @@ require 'sinatra'
 module JsonCrudApi
   class API < Sinatra::Base
 
+    register JsonCrudApi::Session
+    register JsonCrudApi::JsonPayload
     register JsonCrudApi::Crud
+    register JsonCrudApi::JsonErrors
 
     before do
       # HTTPS Only (if configured)
@@ -12,38 +15,14 @@ module JsonCrudApi
         fail_with_error 403, 'SSL_ONLY', 'The API can only be accessed over SSL (HTTPS)'
       end
 
-      # JSON Errors
-      @errors = []
-
       # No-Cache by default
       cache_control :no_cache, :max_age => 0
 
       # Session
-      @user = nil
-      @logged_in = false
-      if settings.respond_to? :auth_client
-        @session_id = env['HTTP_X_SESSION_ID']
-        unless @session_id.nil?
-          @user = settings.auth_client.get(@session_id)
-          @logged_in = !@user.nil?
-        end
-      end
-      settings.services.each do |k,service|
-        service.set_user @user if service.respond_to? :set_user
-      end
+      process_session
 
       # JSON Payload
-      request.body.rewind
-      body = request.body.read
-      if body.length > 2
-        begin
-          @payload = JSON.parse body, :symbolize_names => true
-        rescue JSON::ParserError
-          fail_with_error 422, 'JSON_PARSE_ERROR',  'The JSON payload cannot be parsed'
-        end
-      else
-        @payload = nil
-      end
+      process_json_payload
 
       # CORS
       content_type 'application/json; charset=utf-8'
@@ -51,45 +30,6 @@ module JsonCrudApi
       response.headers['Access-Control-Allow-Headers'] = 'Content-Type'
     end
 
-    def logged_in?
-      @logged_in
-    end
-
-    def add_error(code, message, reference = nil)
-      @errors = [] if @errors.nil?
-
-      error = {
-        :code => code,
-        :message => message,
-      }
-      error[:reference] = reference unless reference.nil?
-      @errors.push error
-    end
-
-    def fail_with_error(status, code, message, reference = nil)
-      add_error code,message,reference
-      fail_with_errors status
-    end
-
-    def fail_with_errors(status = 422)
-      halt status, JSON.fast_generate({
-        :success => false,
-        :errors => @errors
-      })
-    end
-
-    def fail_not_found
-      fail_with_error 404, 'NOT_FOUND','The resource cannot be found.'
-    end
-
-    def fail_unauthorized
-      fail_with_error 401, 'UNAUTHORIZED','Authorization is required to perform this operation on the resource.'
-    end
-
-    def fail_forbidden
-      fail_with_error 403, 'FORBIDDEN','The user is not allowed to perform this operation on the resource.'
-    end
-
     not_found do
       fail_not_found
     end

data/lib/json-crud-api/crud.rb

@@ -1,71 +1,69 @@
+require 'json'
+
 module JsonCrudApi
   module Crud
 
     def crud_api(url, key, options = [])
 
       unless options.include? :disable_read
+        get url do crud_get_all(key) end unless options.include? :disable_get_all
+        get url+"/:id" do crud_get(key) end unless options.include? :disable_get
+      end
 
-        unless options.include? :disable_get_all
-          get url do
-            service = settings.services[key]
-            presenter = settings.presenters[key]
-            fail_unauthorized unless service.user_authorized_for? :get_all
-            entities = service.get_all
-            fail_not_found if entities.nil?
+      unless options.include? :disable_write
+        post url do crud_post(key) end unless options.include? :disable_post
+        put url+"/:id" do crud_put(key) end unless options.include? :disable_put
+        delete url+"/:id" do crud_delete(key) end unless options.include? :disable_delete
+      end
 
-            JSON.fast_generate settings.presenters[key].render(entities, :get_all)
-          end
-        end
+    end
 
-        unless options.include? :disable_get
-          get url+"/:id" do
-            service = settings.services[key]
-            presenter = settings.presenters[key]
-            fail_unauthorized unless service.user_authorized_for? :get
-            entity = service.get(params["id"])
-            fail_not_found if entity.nil?
+    private
 
-            JSON.fast_generate settings.presenters[key].render(entity, :get)
-          end
-        end
+    def crud_get_all(key)
+      service = settings.services[key]
+      presenter = settings.presenters[key]
+      return fail_unauthorized unless service.user_authorized_for? :get_all
+      entities = service.get_all
+      return fail_not_found if entities.nil?
 
-      end
+      JSON.fast_generate presenter.render(entities, :get_all)
+    end
 
-      unless options.include? :disable_write
+    def crud_get(key)
+      service = settings.services[key]
+      presenter = settings.presenters[key]
+      return fail_unauthorized unless service.user_authorized_for? :get
+      entity = service.get(params["id"])
+      return fail_not_found if entity.nil?
 
-        unless options.include? :disable_post
-          post url do
-            service = settings.services[key]
-            presenter = settings.presenters[key]
-            fail_unauthorized unless service.user_authorized_for? :create
-            entity = service.create(presenter.parse(@payload, :post))
+      JSON.fast_generate presenter.render(entity, :get)
+    end
 
-            JSON.fast_generate settings.presenters[key].render(entity, :post)
-          end
-        end
+    def crud_post(key)
+      service = settings.services[key]
+      presenter = settings.presenters[key]
+      return fail_unauthorized unless service.user_authorized_for? :create
+      entity = service.create(presenter.parse(@payload, :post))
 
-        unless options.include? :disable_put
-          put url+"/:id" do
-            service = settings.services[key]
-            presenter = settings.presenters[key]
-            fail_unauthorized unless service.user_authorized_for? :update
-            fail_not_found unless service.update(params["id"], presenter.parse(@payload, :put))
-            entity = service.get(params["id"])
-            JSON.fast_generate settings.presenters[key].render(entity, :put)
-          end
-        end
+      JSON.fast_generate presenter.render(entity, :post)
+    end
 
-        unless options.include? :disable_delete
-          delete url+"/:id" do
-            service = settings.services[key]
-            presenter = settings.presenters[key]
-            fail_unauthorized unless service.user_authorized_for? :delete
-            fail_not_found unless service.delete(params["id"])
-            204
-          end
-        end
+    def crud_put(key)
+      service = settings.services[key]
+      presenter = settings.presenters[key]
+      return fail_unauthorized unless service.user_authorized_for? :update
+      return fail_not_found unless service.update(params["id"], presenter.parse(@payload, :put))
+      entity = service.get(params["id"])
+      JSON.fast_generate presenter.render(entity, :put)
+    end
 
-      end
+    def crud_delete(key)
+      service = settings.services[key]
+      presenter = settings.presenters[key]
+      return fail_unauthorized unless service.user_authorized_for? :delete
+      return fail_not_found unless service.delete(params["id"])
+      204
     end
   end
 end

data/lib/json-crud-api/json_errors.rb

@@ -0,0 +1,45 @@
+require 'json'
+
+module JsonCrudApi
+  module JsonErrors
+
+    def clear_errors 
+      @errors = []
+    end
+
+    def add_error(code, message, reference = nil)
+      @errors = [] if @errors.nil?
+
+      error = {
+        :code => code,
+        :message => message,
+      }
+      error[:reference] = reference unless reference.nil?
+      @errors.push error
+    end
+
+    def fail_with_error(status, code, message, reference = nil)
+      add_error code,message,reference
+      fail_with_errors status
+    end
+
+    def fail_with_errors(status = 422)
+      halt status, JSON.fast_generate({
+        :success => false,
+        :errors => @errors
+      })
+    end
+
+    def fail_not_found
+      fail_with_error 404, 'NOT_FOUND','The resource cannot be found.'
+    end
+
+    def fail_unauthorized
+      fail_with_error 401, 'UNAUTHORIZED','Authorization is required to perform this operation on the resource.'
+    end
+
+    def fail_forbidden
+      fail_with_error 403, 'FORBIDDEN','The user is not allowed to perform this operation on the resource.'
+    end
+  end
+end

data/lib/json-crud-api/json_payload.rb

@@ -0,0 +1,21 @@
+require 'json'
+
+module JsonCrudApi
+  module JsonPayload
+    def process_json_payload
+      request.body.rewind
+      body = request.body.read 
+      unless body.length > 2
+        @payload = nil
+        return
+      end
+
+      begin
+        @payload = JSON.parse body, :symbolize_names => true
+      rescue JSON::ParserError
+        @payload = nil
+        fail_with_error 422, 'JSON_PARSE_ERROR',  'The JSON payload cannot be parsed'
+      end
+    end
+  end
+end

data/lib/json-crud-api/presenter.rb

@@ -8,41 +8,49 @@ module JsonCrudApi
       @exclude = options[:exclude]
       @include = options[:include]
 
+      # Properties Cache
+      @properties = { :render => {}, :parse => {} }
+
       throw "Model must be defined" if @model.nil?
     end
 
     def render(data, operation = nil)
       return data.map {|d| render(d, operation) } if data.is_a?(Array)
 
-      Hash[get_properties(:render, operation).map { |p| [p, data.send(p)] }]
+      unless @properties[:render].has_key? operation
+        @properties[:render][operation] = get_properties(:render, operation)
+      end
+      Hash[@properties[:render][operation].map { |p| [p, data.send(p)] }]
     end
 
     def parse(data, operation = nil)
       return data.map {|d| parse(d, operation) } if data.is_a?(Array)
 
-      Hash[get_properties(:parse, operation).map { |p| [p,data[p]] }]
+      unless @properties[:parse].has_key? operation
+        @properties[:parse][operation] = get_properties(:parse, operation)
+      end
+
+      out = Hash.new
+      data.each_pair { |k,v| out[k] = v if @properties[:parse][operation].include?(k) }
+      out
     end
 
     def get_properties(method, operation)
       properties = @model.properties.map { |p| p.name.to_sym }
-      unless @exclude.nil?
-        properties -= @exclude[:all] unless @exclude[:all].nil?
-        properties -= @exclude[operation] unless @exclude[operation].nil?
-        unless @exclude[method].nil?
-          properties -= @exclude[method][:all] unless @exclude[method][:all].nil?
-          properties -= @exclude[method][operation] unless @exclude[method][operation].nil?
-        end
-      end
-      unless @include.nil?
-        properties += @include[:all] unless @include[:all].nil?
-        properties += @include[operation] unless @include[operation].nil?
-        unless  @include[method].nil?
-          properties += @include[method][:all] unless @include[method][:all].nil?
-          properties += @include[method][operation] unless @include[method][operation].nil?
-        end
-      end
+      properties -= filter_properties @exclude, method, operation unless @exclude.nil?
+      properties += filter_properties @include, method, operation unless @include.nil?
       properties
     end
 
+    def filter_properties(parameter, method, operation)
+      properties = []
+      properties += parameter[:all] unless parameter[:all].nil?
+      properties += parameter[operation] unless parameter[operation].nil?
+      unless parameter[method].nil?
+        properties += parameter[method][:all] unless parameter[method][:all].nil?
+        properties += parameter[method][operation] unless parameter[method][operation].nil?
+      end
+      properties
+    end
   end
 end

data/lib/json-crud-api/session.rb

@@ -0,0 +1,24 @@
+require 'json'
+
+module JsonCrudApi
+  module Session
+    def process_session
+      @user = nil
+      @logged_in = false
+      if settings.respond_to? :auth_client
+        @session_id = env['HTTP_X_SESSION_ID']
+        unless @session_id.nil?
+          @user = settings.auth_client.get(@session_id)
+          @logged_in = !@user.nil?
+        end
+      end
+      settings.services.each do |k,service|
+        service.set_user @user if service.respond_to? :set_user
+      end
+    end
+
+    def logged_in?
+      @logged_in
+    end
+  end
+end

data/lib/json-crud-api.rb

@@ -1,5 +1,8 @@
+require "json-crud-api/session"
 require "json-crud-api/presenter"
 require "json-crud-api/service"
 require "json-crud-api/crud"
-require "json-crud-api/api"
-require "json-crud-api/auth_client"
+require "json-crud-api/json_payload"
+require "json-crud-api/json_errors"
+require "json-crud-api/auth_client"
+require "json-crud-api/api"

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'rack/test'
+
+require "json-crud-api"
+
+RSpec.configure do |c|
+end

data/spec/unit/api_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe JsonCrudApi::API do
+  include Rack::Test::Methods
+
+  def app
+    JsonCrudApi::API
+  end
+
+  # TODO: Moar Specs!
+end

data/spec/unit/auth_client_spec.rb

@@ -1,4 +1,4 @@
-require "helper"
+require "spec_helper"
 
 describe JsonCrudApi::AuthClient do
   before(:each) do
@@ -13,89 +13,89 @@ describe JsonCrudApi::AuthClient do
 
   describe '#initialize' do
     it 'should inject dependencies correctly' do
-      @client.redis.should be @mock_redis
-      @client.session_ttl.should be 200
-      @client.prefix.should be 789
+      expect(@client.redis).to be @mock_redis
+      expect(@client.session_ttl).to be 200
+      expect(@client.prefix).to be 789
     end
   end
 
   describe '#get' do
     it 'should call get_redis_key and redis get' do
-      @client.should_receive(:get_redis_key).with('one')
-      @mock_redis.should_receive(:get).and_return nil
+      expect(@client).to receive(:get_redis_key).with('one')
+      expect(@mock_redis).to receive(:get).and_return nil
       @client.get('one')
     end
 
     it 'should return nil if redis get return nil' do
-      @mock_redis.should_receive(:get).and_return nil
-      @client.get('one').should be nil
+      expect(@mock_redis).to receive(:get).and_return nil
+      expect(@client.get('one')).to be_nil
     end
 
     it 'should call touch if redis get is non nil' do
-      @mock_redis.should_receive(:get).and_return '{}'
-      @client.should_receive(:touch).with('789one')
+      expect(@mock_redis).to receive(:get).and_return '{}'
+      expect(@client).to receive(:touch).with('789one')
       @client.get('one')
     end
 
     it 'should parse JSON from redis get' do
-      @mock_redis.should_receive(:get).and_return '{"five":5}'
-      @client.should_receive(:touch).with('789one')
-      @client.get('one').should eq({ :five => 5 })
+      expect(@mock_redis).to receive(:get).and_return '{"five":5}'
+      expect(@client).to receive(:touch).with('789one')
+      expect(@client.get('one')).to eq({ :five => 5 })
     end
   end
 
   describe '#delete' do
     it 'should call get_redis_key and redis exists and return false if exists is false' do
-      @client.should_receive(:get_redis_key).with('one')
-      @mock_redis.should_receive(:exists).and_return false
-      @client.delete('one').should be false
+      expect(@client).to receive(:get_redis_key).with('one')
+      expect(@mock_redis).to receive(:exists).and_return false
+      expect(@client.delete('one')).to be false
     end
 
     it 'should call redis del and return true if redis exists is true' do
-      @mock_redis.should_receive(:exists).and_return true
-      @mock_redis.should_receive(:del).with('789one')
-      @client.delete('one').should be true
+      expect(@mock_redis).to receive(:exists).and_return true
+      expect(@mock_redis).to receive(:del).with('789one')
+      expect(@client.delete('one')).to be true
     end
   end
 
   describe '#touch' do
     it 'should call get_redis_key and redis exists and return false if exists is false' do
-      @client.should_receive(:get_redis_key).with('one')
-      @mock_redis.should_receive(:exists).and_return false
-      @client.touch('one').should be false
+      expect(@client).to receive(:get_redis_key).with('one')
+      expect(@mock_redis).to receive(:exists).and_return false
+      expect(@client.touch('one')).to be false
     end
 
     it 'should call redis expire and return true if redis exists is true' do
-      @mock_redis.should_receive(:exists).and_return true
-      @mock_redis.should_receive(:expire).with('789one', 200)
-      @client.touch('one').should be true
+      expect(@mock_redis).to receive(:exists).and_return true
+      expect(@mock_redis).to receive(:expire).with('789one', 200)
+      expect(@client.touch('one')).to be true
     end
   end
 
   describe '#get_redis_key' do
     it 'should return key if prefix is nil' do
       @client.prefix = nil
-      @client.get_redis_key('one').should eq 'one'
+      expect(@client.get_redis_key('one')).to eq 'one'
     end
 
     it 'should return key.to_s if prefix is nil' do
       @client.prefix = nil
-      @client.get_redis_key(1).should eq '1'
+      expect(@client.get_redis_key(1)).to eq '1'
     end
 
     it 'should return prefix plus key if prefix is not nil' do
       @client.prefix = 'pre-'
-      @client.get_redis_key('one').should eq 'pre-one'
+      expect(@client.get_redis_key('one')).to eq 'pre-one'
     end
 
     it 'should return prefix plus key.to_s if prefix is not nil' do
       @client.prefix = 'post-'
-      @client.get_redis_key(1).should eq 'post-1'
+      expect(@client.get_redis_key(1)).to eq 'post-1'
     end
 
     it 'should return prefix.to_s plus key.to_s if prefix is not nil' do
       @client.prefix = 5
-      @client.get_redis_key(1).should eq '51'
+      expect(@client.get_redis_key(1)).to eq '51'
     end
   end
 end