jsonapi_for_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9cfc12b29fbd2b7976e2f8afdd25efd52b8f1e3
+  data.tar.gz: 4a677ebb54f964c8e339b56dfe2c03d886f669b9
+SHA512:
+  metadata.gz: 9ded9261047e1a2f118251b7003ee0113722c3ef9086d9228d8d1a4943c75633ea509e91519f987c6ea93e664e86beadc55c53c8f86e61bf1b9af2546f6f9628
+  data.tar.gz: b5b734f5214dbde8371c756974a335e92deba05bf18888687b8a7701eac471b16e99190c863151022fe7b7f46ebbf5634b6d8ed056824b2469cf2c84c4b5b06a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Doga Armangil
+
+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.md

@@ -0,0 +1,229 @@
+# JsonapiForRails
+A [Rails](http://rubyonrails.org/) 5+ plugin for providing a [JSONAPI v1.0](http://jsonapi.org/format/1.0/) API from your application with very little coding.
+
+## Usage
+
+### 1. Set up one API controller per model
+
+Generate a controller for each model that will be accessible from your API. Controller names need to be the plural version of your model names.
+
+```bash
+$ # Go to the root directory of your existing Rails application
+$ cd path/to/railsapp
+$
+$ # Generate your models
+$ bin/rails generate model author
+$ bin/rails generate model article
+$
+$ # Generate your API controllers
+$ bin/rails generate controller authors
+$ bin/rails generate controller articles
+```
+
+Then enable JSONAPI in a parent class of your API controllers. 
+
+```ruby
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base # or ActionController::API
+
+  # Enable JSONAPI
+  acts_as_jsonapi_resources
+
+  # ...
+end
+```
+
+If only some of your controllers are JSONAPI controllers, then create a parent controller for only those controllers, and enable JSONAPI inside that controller rather than `ApplicationController`. 
+
+```bash
+$ cat > app/controllers/jsonapi_resources_controller.rb
+
+class JsonapiResourcesController < ApplicationController
+  acts_as_jsonapi_resources
+
+  # ...
+end
+```
+
+```ruby
+# app/controllers/authors_controller.rb
+
+# Change the API controller's parent class
+class AuthorsController < JsonapiResourcesController
+  # ...
+end
+
+# Do the same with ArticlesController
+```
+
+### 2. Configure your API controller routes
+Update your application routes as follows:
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+
+  scope '/api/v1' do # Optional scoping
+
+    [ # List your API controllers here
+      :authors, :articles
+    ].each do |resources_name|
+      resources resources_name do
+        controller resources_name do
+          get     'relationships/:relationship', action: "relationship_show"
+          patch   'relationships/:relationship', action: "relationship_update"
+          post    'relationships/:relationship', action: "relationship_add"
+          delete  'relationships/:relationship', action: "relationship_remove"
+        end
+      end
+    end
+
+  end
+
+  # ...
+end
+
+```
+
+### 3. Verify your setup
+After populating your database and launching the built-in Rails server with the `bin/rails server` shell command, you can issue some HTTP requests to your API and verify the correctness of the responses.
+
+```bash
+$ # Get the list of articles
+$ curl 'http://localhost:3000/api/v1/articles'
+{"data":[{"type":"articles","id":184578894},{"type":"articles","id":388548390},{"type":"articles","id":618037523},{"type":"articles","id":994552601}]}
+$
+$ # Get an article
+$ curl 'http://localhost:3000/api/v1/articles/184578894'
+{"data":{"type":"articles","id":618037523,"attributes":{"title":"UK bank pay and bonuses in the spotlight as results season starts","content":"The pay deals handed to the bosses of Britain’s biggest banks will be in focus ...","created_at":"2016-02-22T16:57:43.401Z","updated_at":"2016-02-22T16:57:43.401Z"},"relationships":{"author":{"data":{"type":"authors","id":1023487079}}}}}
+$
+$ # Get only the title of an article, include the author name
+$ curl 'http://localhost:3000/api/v1/articles/184578894?filter%5Barticles%5D=title,author;include=author;filter%5Bauthors%5D=name'
+{"data":{"type":"articles","id":618037523,"attributes":{"title":"UK bank pay and bonuses in the spotlight as results season starts"},"relationships":{"author":{"data":{"type":"authors","id":1023487079}}}},"include":[{"data":{"type":"authors","id":1023487079,"attributes":{"name":"..."},"relationships":{}}}]}
+
+```
+
+## Modifying the default API behaviour
+By default, all API end-points are accessible to all clients, and all end-points behave the same way for all clients. In a real-world setting, you may want to restrict access to an end-point and/or change the behaviour of an end-point depending on the client. 
+
+### Client authentication
+Clients can be authenticated with a `before_action` method in your API controller. Inside controllers, instance variable names starting with the `@jsonapi_` prefix and method names starting with the `jsonapi_` prefix are reserved by *jsonapi_for_rails*, so try to avoid those.
+
+```ruby
+# app/controllers/jsonapi_resources_controller.rb
+class JsonapiResourcesController < ApplicationController
+  acts_as_jsonapi_resources
+
+  before_action :authenticate
+
+private
+  def authenticate
+    # ...
+  end
+end
+```
+
+### Access control
+Access control for authenticated and unauthenticated clients can be implemented in `before_action` methods in your API controllers.
+
+```ruby
+# app/controllers/jsonapi_resources_controller.rb
+class JsonapiResourcesController < ApplicationController
+  acts_as_jsonapi_resources
+
+  before_action :permit_read, only: [
+    :index,
+    :show,
+    :relationship_show
+  ]
+
+  before_action :permit_write, only: [
+    :create, 
+    :update, 
+    :destroy,
+    :relationship_update,
+    :relationship_add,
+    :relationship_remove
+  ]
+
+private
+  def permit_read
+    # ...
+  end
+
+  def permit_write
+    # ...
+  end
+end
+```
+
+### Overriding an API end-point
+The `bin/rails routes` shell command shows you the end-points that *jsonapi_for_rails* defines. In order to change the behaviour of an action, you can define an action with the same name inside an API controller. *jsonapi_for_rails* provides utility methods and instance variables that can help you.
+
+```ruby
+# app/controllers/articles_controller.rb
+class ArticlesController < JsonapiResourcesController 
+
+  def index
+    jsonapi_model_class      # =>  Article
+    jsonapi_model_class_name # => "Article"
+    jsonapi_model_type       # => :articles
+
+    # ...
+  end
+
+  def show
+    @jsonapi_record.to_jsonapi_hash # => {data: {...}}
+
+    # ...
+  end
+
+  def relationship_show
+    @jsonapi_relationship # => {:definition=>{:name=>:author, :type=>:to_one, :receiver=>{:type=>:authors, :class=>Author}}
+
+    # ...
+  end
+
+end
+```
+
+## Implementation status
+* [Inclusion of related resources](http://jsonapi.org/format/1.0/#fetching-includes) is currently only implemented for requests that return a single resource, and relationship paths are not supported. 
+* [Sparse fieldsets](http://jsonapi.org/format/1.0/#fetching-sparse-fieldsets) is currently only implemented for requests that return a single resource. 
+* [Sorting](http://jsonapi.org/format/1.0/#fetching-sorting) is currently not implemented.
+* [Pagination](http://jsonapi.org/format/1.0/#fetching-pagination) is currently not implemented.
+* [Deleting resources](http://jsonapi.org/format/1.0/#crud-deleting) is currently not implemented.
+* Test coverage is sparse.
+
+## Installation
+
+### Edge version
+
+```bash
+$ # Clone this repository
+$ git clone 'https://github.com/doga/jsonapi_for_rails.git'
+$
+$ # Update your Rails application's gem file
+$ cat >> path/to/Gemfile
+
+group :development do
+  gem 'jsonapi_for_rails', path: 'path/to/jsonapi_for_rails'
+  #gem 'jsonapi_for_rails', git: 'https://github.com/doga/jsonapi_for_rails.git'
+end
+```
+
+### Latest stable version
+
+```bash
+$ # Update your Rails application's gem file
+$ cat >> path/to/Gemfile
+
+gem 'jsonapi_for_rails'
+```
+
+## Contributing
+If you find a bug in this project, have trouble following the documentation or have a question about the project – create an [issue](https://guides.github.com/activities/contributing-to-open-source/#contributing).
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'JsonapiForRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/jsonapi_for_rails/controller/actions/object.rb

@@ -0,0 +1,293 @@
+module JsonapiForRails::Controller
+
+	module Actions
+		module Object
+			def self.included receiver
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			module InstanceMethods
+				# TODO: pagination
+				def index
+					@json = {data: []}
+					jsonapi_model_class.all.each do |record|
+						@json[:data] << {
+							type: record.class.to_s.underscore.pluralize, # TODO: factor out type generation from class
+							id:   record.id
+						}
+					end
+					render_json @json
+				end
+
+				# implements Create and Update operations
+				def create
+					begin
+						# attributes
+						attrs = received_attributes
+						if attrs
+							if @jsonapi_record
+								# update
+								@jsonapi_record.update! attrs
+							else
+								# create
+								@jsonapi_record = jsonapi_model_class.create! attrs
+							end
+						end
+
+						# relationships
+						received_relationships.each do |relationship|
+							# to-one
+							if relationship[:definition][:type] == :to_one
+								@jsonapi_record.send :"#{relationship[:definition][:name]}=", relationship[:params][:data]
+								next
+							end
+
+							# to-many
+							@jsonapi_record.send(relationship[:definition][:name]).send :clear # initialize the relation
+							
+							relationship[:params][:data].each do |item|
+								object = relationship[:receiver][:class].find_by_id item[:id]
+								@jsonapi_record.send(relationship[:definition][:name]).send :<<, object
+							end
+						end
+					rescue NameError => e
+
+						# error when creating record			
+						render_error 500, "Model class not found."
+						return
+					rescue 
+						# error when creating relationship?
+						@jsonapi_record.destroy if @jsonapi_record 
+
+						render_error 500, "Record could not be created."
+						return
+					end
+					show
+				end
+
+				def show
+					@json = @jsonapi_record.to_jsonapi_hash(
+						@jsonapi_sparse_fieldsets[jsonapi_model_type]
+					)
+					#$stderr.puts "#{@json}" 
+
+					# Include resources
+					# TODO: relationship paths when including resources (http://jsonapi.org/format/1.0/#fetching-includes)
+					if @jsonapi_include and @json[:data][:relationships]
+						@json[:include] = []
+						@jsonapi_include.each do |rel_name|
+							rel = @json[:data][:relationships][rel_name]
+							next unless rel
+							rel = rel[:data]
+							next unless rel
+							rel = [rel] if rel.kind_of?(Hash)
+							rel.each do |r|
+								type = r[:type].to_sym
+								klass = nil
+								begin
+									klass = r[:type].singularize.camelize.constantize
+								rescue NameError => e
+									next									
+								end
+								r = klass.find_by_id r[:id]
+								next unless r
+
+								@json[:include] << r.to_jsonapi_hash(
+									@jsonapi_sparse_fieldsets[type]
+								)
+							end
+						end
+					end
+
+					render_json @json
+				end
+
+				def update
+					create
+				end
+
+				def destroy
+					render_error 500, "Not implemented."
+				end
+
+				# private
+
+				# Extracts record attributes from received params. 
+				# Use this for creating/updating a database record.
+				# Note that relationships (has_one associations etc) are filtered out
+				# but are still available in the original params.
+				def received_attributes
+					begin
+						params.require(
+							:data
+						).require(
+							:attributes
+						).permit(
+							*jsonapi_model_class.attribute_names
+						).reject do |key, value|
+							# ignore automatically generated attributes
+							%w(
+								id 
+								created_at created_on 
+								updated_at updated_on
+							).include?(
+								key.to_s
+							) or 
+
+							# ignore reference attributes
+							key.to_s =~ /_id$/
+						end
+					rescue  ActionController::ParameterMissing => e
+						nil
+					end
+				end
+
+				def relationships
+					jsonapi_model_class.reflect_on_all_associations.collect do |association|
+						type = nil
+
+						type = :to_one if [
+							ActiveRecord::Reflection::HasOneReflection, 
+							ActiveRecord::Reflection::BelongsToReflection
+						].include? association.class
+
+						type = :to_many if [
+							ActiveRecord::Reflection::HasManyReflection, 
+							ActiveRecord::Reflection::HasAndBelongsToManyReflection
+						].include? association.class
+
+						next unless type
+
+						{
+							name: association.name,
+							type: type,
+							receiver: {
+								type: association.klass.to_s.underscore.pluralize.to_sym,
+								class: association.klass.to_s.constantize
+							}
+						}
+					end.compact
+				end
+
+				def received_relationships
+					rels = relationships
+					if params[:relationship] # only one relationship received for relationship action
+						rels.select! do |rel|
+							rel[:name].to_sym == params[:relationship].to_sym
+						end
+						if request.method == "GET"
+							# no relationship received, return definition only
+							return rels.collect do |rel|
+								{definition: rel}
+							end
+						end
+					end
+					rels.collect do |relationship|
+						begin
+							received_params = nil
+							if params[:relationship]
+								received_params =  params.permit({
+									data: [
+										:type, :id
+									]
+								})
+							else
+								received_params =  params.require( 
+									:data
+								).require(
+									:relationships
+								).require(
+									relationship[:name]
+								).permit({
+									data: [
+										:type, :id
+									]
+								})
+							end
+							# => {"data"=>{"type"=>"users", "id"=>1}}                                         # sample value for a to-one association
+							# => {"data"=>[{"type"=>"properties", "id"=>1}, {"type"=>"properties", "id"=>2}]} # sample value for a to-many association
+
+							# is received data conformant to the database schema? 
+							conformant = true
+							loop do
+								# to-many
+								if received_params[:data].kind_of? Array
+									if relationship[:type] != :to_many
+										conformant = false
+										break
+									end
+									received_params[:data].each do |item|
+										next if item[:type] == relationship[:receiver][:type]
+										conformant = false
+										break
+									end
+									break
+								end
+
+								# to-one
+								if relationship[:type] != :to_one
+									conformant = false
+									break
+								end
+								conformant = false unless received_params[:data][:type] == relationship[:receiver][:type]
+
+								break
+							end
+							next unless conformant
+
+							{
+								definition: relationship,
+								params:     received_params
+							}
+						rescue ActionController::ParameterMissing => e
+
+							# nil assignment to to-one relationship?
+							if relationship[:type] == :to_one
+								begin
+									if params[:relationship] # relationship action
+										received_params =  params.permit(
+											:data
+										)
+									else
+										received_params =  params.require( 
+											:data
+										).require(
+											:relationships
+										).require(
+											relationship[:name]
+										).permit(
+											:data
+										)
+									end
+
+									# received nil?
+									next if received_params[:data] # TODO: should return error to client?
+
+									next {
+										definition: relationship,
+										params:     received_params
+									}
+								rescue ActionController::ParameterMissing => e
+								end
+							end
+
+							nil
+						end
+					end.compact
+				end
+
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					private :received_attributes
+					private :relationships
+					private :received_relationships
+				end
+			end
+
+		end
+	end
+
+end

data/lib/jsonapi_for_rails/controller/actions/relationship.rb

@@ -0,0 +1,111 @@
+module JsonapiForRails::Controller
+
+	module Actions
+		module Relationship
+			def self.included receiver
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			module InstanceMethods
+				# GET
+				def relationship_show
+					#$stderr.puts "JsonapiForRails::Controller::Actions::Relationship#relationship_show called" 
+					rel = @jsonapi_record.send @jsonapi_relationship[:definition][:name]
+
+					@json = nil
+					if @jsonapi_relationship[:definition][:type] == :to_one
+						@json = {
+							type: @jsonapi_relationship[:definition][:receiver][:type],
+							id:   rel.id
+						}
+					elsif @jsonapi_relationship[:definition][:type] == :to_many
+						@json = rel.collect do |r|
+							{
+								type: @jsonapi_relationship[:definition][:receiver][:type],
+								id:   r.id
+							}
+						end
+					end
+					@json = {data: @json}
+
+					render_json @json
+				end
+
+				# PATCH
+				def relationship_update
+					if @jsonapi_relationship[:definition][:type] == :to_many
+						render_error 403, 'Replacing all members of a to-many relationship is forbidden.'
+						return
+					end
+
+					related = nil
+					if @jsonapi_relationship[:params][:data]
+						related = @jsonapi_relationship[:definition][:receiver][:class].find_by_id(
+							@jsonapi_relationship[:params][:data][:id]
+						)
+						unless related
+							render_error 403, 'Record not found.'
+							return
+						end
+					end
+
+					@jsonapi_record.send :"#{@jsonapi_relationship[:definition][:name]}=", related
+					@jsonapi_record.save
+				end
+
+				# POST for to-many relations only
+				def relationship_add
+					unless @jsonapi_relationship[:definition][:type] == :to_many
+						render_error 403, 'Operation allowed for to-many relationships only.'
+						return
+					end
+					
+					records = @jsonapi_relationship[:params][:data].collect do |record|
+						record = @jsonapi_relationship[:definition][:receiver][:class].find_by_id(
+							record[:id]
+						)
+						unless record
+							render_error 403, "Non-existing record #{record.inspect}."
+							return
+						end
+						record
+					end
+
+					records.each do |record|
+						@jsonapi_record.send(@jsonapi_relationship[:definition][:name]) << record
+					end
+				end
+
+				# DELETE for to-many relations only
+				def relationship_remove
+					unless @jsonapi_relationship[:definition][:type] == :to_many
+						render_error 403, 'Operation allowed for to-many relationships only.'
+						return
+					end
+					
+					records = @jsonapi_relationship[:params][:data].collect do |record|
+						record = @jsonapi_relationship[:definition][:receiver][:class].find_by_id(
+							record[:id]
+						)
+						unless record
+							render_error 403, "Non-existing record #{record.inspect}."
+							return
+						end
+						record
+					end
+
+					records.each do |record|
+						@jsonapi_record.send(@jsonapi_relationship[:definition][:name]).delete record
+					end
+				end
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+				end
+			end
+		end
+	end
+
+end

data/lib/jsonapi_for_rails/controller/before_actions/include.rb

@@ -0,0 +1,30 @@
+module JsonapiForRails::Controller
+
+	module BeforeActions
+		module Include
+
+			def self.included receiver
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					before_action :jsonapi_include
+					private :jsonapi_include
+				end
+			end
+
+			module InstanceMethods
+				def jsonapi_include
+					#@jsonapi_include = nil
+					return unless params[:include] 
+
+					@jsonapi_include = params[:include].split(',').map{|rel| rel.strip.to_sym }
+				end
+
+			end
+		end
+	end
+
+end

data/lib/jsonapi_for_rails/controller/before_actions/record.rb

@@ -0,0 +1,51 @@
+module JsonapiForRails::Controller
+
+	module BeforeActions
+		module Record
+
+			def self.included receiver
+				#$stderr.puts "JsonapiForRails::Controller::RecordFromRequest included into #{receiver}" 
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					before_action :jsonapi_require_record, except: [
+						:index, 
+						:create
+					]
+					private :jsonapi_require_record
+				end
+			end
+
+			module InstanceMethods
+				def jsonapi_require_record
+					#$stderr.puts "@jsonapi_sparse_fieldsets: #{@jsonapi_sparse_fieldsets.inspect}" 
+					#$stderr.puts "JsonapiForRails::Controller::RecordFromRequest#jsonapi_require_record called" 
+					if params[:relationship] 
+						# relationship action
+						@jsonapi_record = jsonapi_model_class.find_by_id params["#{jsonapi_model_class_name.underscore}_id"].to_i
+					else
+						# CRUD action
+						@jsonapi_record = jsonapi_model_class
+=begin
+						if false and @jsonapi_sparse_fieldsets[jsonapi_model_type] 
+							@jsonapi_record = @jsonapi_record.select(
+								@jsonapi_sparse_fieldsets[jsonapi_model_type]
+							) 
+						end
+=end
+						@jsonapi_record = @jsonapi_record.find_by_id params[:id].to_i
+					end
+					#$stderr.puts "@jsonapi_record: #{@jsonapi_record.inspect}" 
+					return if @jsonapi_record
+
+					render_error 401, "Bad request."
+				end
+
+			end
+		end
+	end
+
+end

data/lib/jsonapi_for_rails/controller/before_actions/relationship.rb

@@ -0,0 +1,34 @@
+module JsonapiForRails::Controller
+
+	module BeforeActions
+		module Relationship
+
+			def self.included receiver
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					before_action :jsonapi_require_relationship, only: [
+						:relationship_show,
+						:relationship_update,
+						:relationship_add,
+						:relationship_remove
+					]
+					private :jsonapi_require_relationship
+				end
+			end
+
+			module InstanceMethods
+				def jsonapi_require_relationship
+					#$stderr.puts "JsonapiForRails::Controller::RelationshipFromRequest#jsonapi_require_relationship called" 
+					@jsonapi_relationship = received_relationships.first
+					return if @jsonapi_relationship
+
+					render_error 401, "Bad request."
+				end
+			end
+		end
+	end
+end

data/lib/jsonapi_for_rails/controller/before_actions/sparse_fieldsets.rb

@@ -0,0 +1,39 @@
+module JsonapiForRails::Controller
+
+	module BeforeActions
+		module SparseFieldsets
+
+			def self.included receiver
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					before_action :jsonapi_sparse_fieldsets
+					private :jsonapi_sparse_fieldsets
+				end
+			end
+
+			module InstanceMethods
+				def jsonapi_sparse_fieldsets
+					@jsonapi_sparse_fieldsets = {}
+					return unless params[:fields]
+
+					params[:fields].each do |resources_name, fields|
+						resources_name = resources_name.to_sym
+						fields = 
+							fields.split(',').
+							map{|field| field.strip.to_sym }.
+							select{|e| e =~ /^[A-Za-z1-9_]+$/} # BUG: selector too restrictive
+						next if fields.size.zero?
+						@jsonapi_sparse_fieldsets[resources_name] = fields#.join(',')
+					end 
+
+				end
+
+			end
+		end
+	end
+
+end

data/lib/jsonapi_for_rails/controller/utils/model.rb

@@ -0,0 +1,36 @@
+module JsonapiForRails::Controller
+
+	module Utils
+		module Model
+			def self.included receiver
+				#$stderr.puts "JsonapiForRails::Controller::ModelUtils included into #{receiver}" 
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			module InstanceMethods
+				def jsonapi_model_class_name
+					controller_class_name = "#{self.class}"
+					controller_class_name.underscore.split('_')[0..-2].join('_').camelize.singularize
+				end
+
+				def jsonapi_model_class
+					jsonapi_model_class_name.constantize # Object.const_get jsonapi_model_class_name
+				end
+
+				# used in returned JSON API data
+				def jsonapi_model_type
+					jsonapi_model_class_name.underscore.pluralize.to_sym
+				end
+			end
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					private :jsonapi_model_class_name, :jsonapi_model_class, :jsonapi_model_type
+				end
+			end
+
+		end
+	end
+
+end

data/lib/jsonapi_for_rails/controller/utils/render.rb

@@ -0,0 +1,59 @@
+module JsonapiForRails::Controller
+
+	module Utils
+		module Render
+			def self.included receiver
+				receiver.send :include, InstanceMethods
+				run_macros receiver
+			end
+
+			JSONAPI = {
+				specification: 'http://jsonapi.org/format/',
+				content_type: 'application/vnd.api+json'
+			}.freeze
+
+			def self.run_macros receiver
+				receiver.instance_exec do 
+					private :render_json, :render_error
+				end
+			end
+
+			module InstanceMethods
+				def render_json object
+					unless object
+						render_error 500, 'No message specified.'
+						return
+					end
+
+					@status = 200
+					@json = object
+					@content_type = JSONAPI[:content_type]
+
+					render(
+						json:         @json, 
+						status:       @status, 
+						content_type: @content_type
+					)
+				end
+
+				def render_error status, title
+					@status = status
+					@json = {
+						errors: [
+							{title: title}
+						]
+					}
+					@content_type = JSONAPI[:content_type]
+
+					render(
+						json:         @json, 
+						status:       @status, 
+						content_type: @content_type
+					)
+				end
+			end
+
+		end
+	end
+	
+end

data/lib/jsonapi_for_rails/controller.rb

@@ -0,0 +1,33 @@
+require "jsonapi_for_rails/controller/utils/model"
+require "jsonapi_for_rails/controller/utils/render"
+require "jsonapi_for_rails/controller/before_actions/sparse_fieldsets"
+require "jsonapi_for_rails/controller/before_actions/include"
+require "jsonapi_for_rails/controller/before_actions/record"
+require "jsonapi_for_rails/controller/before_actions/relationship"
+require "jsonapi_for_rails/controller/actions/object"
+require "jsonapi_for_rails/controller/actions/relationship"
+
+
+module JsonapiForRails::Controller
+	extend ActiveSupport::Concern
+
+	included do
+		#$stderr.puts "JsonapiForRails::Controller included into #{self}" 
+	end
+
+	class_methods do
+		def acts_as_jsonapi_resources model: nil
+			#$stderr.puts "JsonapiForRails::Controller macro called from #{self}:\n  acts_as_jsonapi_resources(model: #{model or 'nil'})" 
+
+			include JsonapiForRails::Controller::Utils::Model
+			include JsonapiForRails::Controller::Utils::Render
+			include JsonapiForRails::Controller::BeforeActions::SparseFieldsets
+			include JsonapiForRails::Controller::BeforeActions::Include
+			include JsonapiForRails::Controller::BeforeActions::Record
+			include JsonapiForRails::Controller::BeforeActions::Relationship
+			include JsonapiForRails::Controller::Actions::Object
+			include JsonapiForRails::Controller::Actions::Relationship
+
+		end
+	end
+end

data/lib/jsonapi_for_rails/model.rb

@@ -0,0 +1,94 @@
+module JsonapiForRails::Model
+	extend ActiveSupport::Concern
+
+	included do
+		#$stderr.puts "JsonapiForRails::Model included into #{self}" 
+
+		# Define instance methods
+		class_exec do
+			def to_jsonapi_hash sparse_fieldset=nil
+				#$stderr.puts "JsonapiForRails::Controller::Actions::Object#show called" 
+
+				# attributes
+				attrs = attributes.reject do |key, value|
+					key =~ /^id$|_id$/
+				end
+				if sparse_fieldset
+					attrs.reject! do |key, value|
+						not sparse_fieldset.find{|f| key.to_sym == f}
+					end
+				end
+
+				# relationships
+				relationships = {}
+				self.class.reflect_on_all_associations.each do |association|
+					if sparse_fieldset
+						next unless sparse_fieldset.find{|f| association.name == f}
+					end
+					relationship = {}
+					relationships[association.name] = relationship
+
+					# to-many relationship
+					if [
+						ActiveRecord::Reflection::HasManyReflection, 
+						ActiveRecord::Reflection::HasAndBelongsToManyReflection
+						].include? association.class
+
+						relationship[:data] = []
+						#$stderr.puts "\nreading relationship '#{association.name}' of class '#{association.class}'" 
+						#$stderr.puts "#{@record.send(association.name).inspect}" 
+						self.send(association.name).each do |record|
+							#$stderr.puts "self.#{association.name}: #{record.class}" 
+							relationship[:data] << {
+								type: record.class.to_s.underscore.pluralize, # TODO: factor out type generation from class
+								id:   record.id
+							}
+						end
+
+					# to-one relationship
+					elsif [
+
+						ActiveRecord::Reflection::HasOneReflection, 
+						ActiveRecord::Reflection::BelongsToReflection
+						].include? association.class
+
+						relationship[:data] = nil
+						#$stderr.puts "\nreading relationship '#{association.name}' of class '#{association.class}'" 
+						#$stderr.puts "#{self.send(association.name).inspect}" 
+						if record = self.send(association.name)
+							relationship[:data] = {
+								type: record.class.to_s.underscore.pluralize, # TODO: factor out type generation from class
+								id:   record.id
+							}
+						end
+					end
+				end
+
+				# message
+				{
+=begin
+					meta: {
+						generated_by_class: "#{self.class}"
+					},
+=end
+					data: {
+						type:       jsonapi_model_type,
+						id:         self.id,
+
+						attributes: attrs,
+
+						relationships: relationships
+					}
+				}
+
+			end
+
+			def jsonapi_model_type
+				"#{self.class}".underscore.pluralize.to_sym
+			end
+
+			private :jsonapi_model_type
+		end
+
+	end
+end

data/lib/jsonapi_for_rails/version.rb

@@ -0,0 +1,3 @@
+module JsonapiForRails
+  VERSION = '0.1.0'
+end

data/lib/jsonapi_for_rails.rb

@@ -0,0 +1,15 @@
+
+# TODO: send pull request to add jsonapi_for_rails to JSON API implementations list (http://jsonapi.org/implementations/)
+# TODO: double-check the installation instructions in README.md
+# TODO: 'Contributing' section in README.md
+
+require "jsonapi_for_rails/version"
+require "jsonapi_for_rails/controller"
+require "jsonapi_for_rails/model"
+
+# Add 'acts_as_jsonapi_resources' class method to controllers
+ActionController::Metal.send :include, JsonapiForRails::Controller
+
+# Add 'to_jsonapi_hash' instance method to models
+ActiveRecord::Base.send      :include, JsonapiForRails::Model
+

data/lib/tasks/jsonapi_for_rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :jsonapi_for_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: jsonapi_for_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Doga Armangil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.beta2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.beta2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Jsonapi for Rails empowers your JSON API (http://jsonapi.org/format/)
+  compliant Rails APIs. Implement your REST API with very little coding.
+email:
+- doga.armangil@alumni.epfl.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/jsonapi_for_rails.rb
+- lib/jsonapi_for_rails/controller.rb
+- lib/jsonapi_for_rails/controller/actions/object.rb
+- lib/jsonapi_for_rails/controller/actions/relationship.rb
+- lib/jsonapi_for_rails/controller/before_actions/include.rb
+- lib/jsonapi_for_rails/controller/before_actions/record.rb
+- lib/jsonapi_for_rails/controller/before_actions/relationship.rb
+- lib/jsonapi_for_rails/controller/before_actions/sparse_fieldsets.rb
+- lib/jsonapi_for_rails/controller/utils/model.rb
+- lib/jsonapi_for_rails/controller/utils/render.rb
+- lib/jsonapi_for_rails/model.rb
+- lib/jsonapi_for_rails/version.rb
+- lib/tasks/jsonapi_for_rails_tasks.rake
+homepage: https://github.com/doga/jsonapi_for_rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A Rails plugin for providing JSON API compliant APIs with very little coding.
+test_files: []