jsonapi-resources 0.0.1

data/Rakefile

@@ -0,0 +1,24 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Run tests'
+test_task = Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task default: :test
+
+desc 'Run tests in isolated processes'
+namespace :test do
+  task :isolated do
+    Dir[test_task.pattern].each do |file|
+      cmd = ['ruby']
+      test_task.libs.each { |l| cmd << '-I' << l }
+      cmd << file
+      sh cmd.join(' ')
+    end
+  end
+end

data/jsonapi-resources.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsonapi/resources/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jsonapi-resources'
+  spec.version       = JSONAPI::Resources::VERSION
+  spec.authors       = ['Dan Gebhardt', 'Larry Gebhardt']
+  spec.email         = ['dan@cerebris.com', 'larry@cerebris.com']
+  spec.summary       = %q{Easily support JSON API in Rails.}
+  spec.description   = %q{A resource-centric approach to implementing the controllers, routes, and serializers needed to support the JSON API spec.}
+  spec.homepage      = 'https://github.com/cerebris/jsonapi-resources'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-spec-rails'
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rails', '>= 4.0'
+end

data/lib/jsonapi-resources.rb

@@ -0,0 +1,2 @@
+require 'jsonapi/resource'
+require 'jsonapi/resources/version'

data/lib/jsonapi/active_record_operations_processor.rb

@@ -0,0 +1,17 @@
+require 'jsonapi/operations_processor'
+
+module JSONAPI
+  class ActiveRecordOperationsProcessor < OperationsProcessor
+
+    private
+    def transaction
+      ActiveRecord::Base.transaction do
+        yield
+      end
+    end
+
+    def rollback
+      raise ActiveRecord::Rollback
+    end
+  end
+end

data/lib/jsonapi/association.rb

@@ -0,0 +1,45 @@
+module JSONAPI
+  class Association
+    def initialize(name, options={})
+      @name          = name.to_s
+      @options       = options
+      @key           = options[:key] ? options[:key].to_sym : nil
+      @primary_key   = options.fetch(:primary_key, 'id').to_sym
+      @treat_as_set  = options.fetch(:treat_as_set, false) == true
+    end
+
+    def key
+      @key
+    end
+
+    def primary_key
+      @primary_key
+    end
+
+    def treat_as_set
+      @treat_as_set
+    end
+
+    def serialize_type_name
+      @serialize_type_name
+    end
+
+    class HasOne < Association
+      def initialize(name, options={})
+        super
+        class_name = options.fetch(:class_name, name.to_s.capitalize)
+        @serialize_type_name = class_name.underscore.pluralize.to_sym
+        @key ||= "#{name}_id".to_sym
+      end
+    end
+
+    class HasMany < Association
+      def initialize(name, options={})
+        super
+        class_name = options.fetch(:class_name, name.to_s.capitalize.singularize).to_sym
+        @serialize_type_name = class_name.to_s.underscore.pluralize.to_sym
+        @key ||= "#{name.to_s.singularize}_ids".to_sym
+      end
+    end
+  end
+end

data/lib/jsonapi/error.rb

@@ -0,0 +1,17 @@
+module JSONAPI
+  class Error
+
+    attr_accessor :title, :detail, :id, :href, :code, :path, :links, :status
+
+    def initialize(options={})
+      @title          = options[:title]
+      @detail         = options[:detail]
+      @id             = options[:id]
+      @href           = options[:href]
+      @code           = options[:code]
+      @path           = options[:path]
+      @links          = options[:links]
+      @status         = options[:status]
+    end
+  end
+end

data/lib/jsonapi/error_codes.rb

@@ -0,0 +1,16 @@
+module JSONAPI
+  VALIDATION_ERROR = 100
+  INVALID_RESOURCE = 101
+  FILTER_NOT_ALLOWED = 102
+  INVALID_FIELD_VALUE = 103
+  INVALID_FIELD = 104
+  PARAM_NOT_ALLOWED = 105
+  PARAM_MISSING = 106
+  INVALID_FILTER_VALUE = 107
+  COUNT_MISMATCH = 108
+  KEY_ORDER_MISMATCH = 109
+  KEY_NOT_INCLUDED_IN_URL = 110
+
+  RECORD_NOT_FOUND = 404
+  LOCKED = 423
+end

data/lib/jsonapi/exceptions.rb

@@ -0,0 +1,177 @@
+module JSONAPI
+  module Exceptions
+    class Error < RuntimeError; end
+
+    class InvalidResource < Error
+      attr_accessor :resource
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_RESOURCE,
+                             status: :bad_request,
+                             title: 'Invalid resource',
+                             detail: "#{resource} is not a valid resource.")]
+      end
+    end
+
+    class RecordNotFound < Error
+      attr_accessor :id
+      def initialize(id)
+        @id = id
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::RECORD_NOT_FOUND,
+                             status: :not_found,
+                             title: 'Record not found',
+                             detail: "The record identified by #{id} could not be found.")]
+      end
+    end
+
+    class FilterNotAllowed < Error
+      attr_accessor :filter
+      def initialize(filter)
+        @filter = filter
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::FILTER_NOT_ALLOWED,
+                             status: :bad_request,
+                             title: 'Filter not allowed',
+                             detail: "#{filter} is not allowed.")]
+      end
+    end
+
+    class InvalidFilterValue < Error
+      attr_accessor :filter, :value
+      def initialize(filter, value)
+        @filter = filter
+        @value = value
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_FILTER_VALUE,
+                             status: :bad_request,
+                             title: 'Invalid filter value',
+                             detail: "#{value} is not a valid value for #{filter}.")]
+      end
+    end
+
+    class InvalidFieldValue < Error
+      attr_accessor :field, :value
+      def initialize(field, value)
+        @field = field
+        @value = value
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_FIELD_VALUE,
+                             status: :bad_request,
+                             title: 'Invalid field value',
+                             detail: "#{value} is not a valid value for #{field}.")]
+      end
+    end
+
+    class InvalidField < Error
+      attr_accessor :field, :type
+      def initialize(type, field)
+        @field = field
+        @type = type
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_FIELD,
+                             status: :bad_request,
+                             title: 'Invalid field',
+                             detail: "#{field} is not a valid field for #{type}.")]
+      end
+    end
+
+    class ParametersNotAllowed < Error
+      attr_accessor :params
+      def initialize(params)
+        @params = params
+      end
+
+      def errors
+            params.collect { |param|
+              JSONAPI::Error.new(code: JSONAPI::PARAM_NOT_ALLOWED,
+                             status: :bad_request,
+                             title: 'Param not allowed',
+                             detail: "#{param} is not allowed.")
+            }
+
+      end
+    end
+
+    class ParameterMissing < Error
+      attr_accessor :param
+      def initialize(param)
+        @param = param
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::PARAM_MISSING,
+                             status: :bad_request,
+                             title: 'Missing Parameter',
+                             detail: "The required parameter, #{param}, is missing.")]
+      end
+    end
+
+    class CountMismatch < Error
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::COUNT_MISMATCH,
+                              status: :bad_request,
+                              title: 'Count to key mismatch',
+                              detail: 'The resource collection does not contain the same number of objects as the number of keys.')]
+      end
+    end
+
+    class KeyNotIncludedInURL < Error
+      attr_accessor :key
+      def initialize(key)
+        @key = key
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::KEY_NOT_INCLUDED_IN_URL,
+                              status: :bad_request,
+                              title: 'Key is not included in URL',
+                              detail: "The URL does not support the key #{key}")]
+      end
+    end
+
+    class MissingKey < Error
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::KEY_ORDER_MISMATCH,
+                              status: :bad_request,
+                              title: 'A key is required',
+                              detail: 'The resource object does not contain a key.')]
+      end
+    end
+
+    class RecordLocked < Error
+      attr_accessor :message
+      def initialize(message)
+        @message = message
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::LOCKED,
+                             status: :locked,
+                             title: 'Locked resource',
+                             detail: "#{message}")]
+      end
+    end
+
+    class ValidationErrors < Error
+      attr_accessor :errors
+      def initialize(errors)
+        @errors = errors
+      end
+    end
+
+  end
+end

data/lib/jsonapi/operation.rb

@@ -0,0 +1,151 @@
+module JSONAPI
+  class Operation
+
+    attr_reader :resource_klass
+
+    def initialize(resource_klass)
+      @resource_klass = resource_klass
+    end
+
+    def apply(context)
+    end
+  end
+
+  class CreateResourceOperation < Operation
+    attr_reader :values
+
+    def initialize(resource_klass, values = {})
+      @values = values
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.new
+      resource.replace_fields(@values, context)
+      resource.save
+
+      return JSONAPI::OperationResult.new(:created, resource)
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::OperationResult.new(e.errors.count == 1 ? e.errors[0].code : :bad_request, nil, e.errors)
+    end
+  end
+
+  class RemoveResourceOperation < Operation
+    attr_reader :resource_id
+    def initialize(resource_klass, resource_id)
+      @resource_id = resource_id
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.remove(context)
+
+      return JSONAPI::OperationResult.new(:no_content)
+
+    rescue ActiveRecord::DeleteRestrictionError => e
+      record_locked_error = JSONAPI::Exceptions::RecordLocked.new(e.message)
+      return JSONAPI::OperationResult.new(record_locked_error.errors[0].code, nil, record_locked_error.errors)
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::OperationResult.new(e.errors.count == 1 ? e.errors[0].code : :bad_request, nil, e.errors)
+    end
+  end
+
+  class ReplaceFieldsOperation < Operation
+    attr_reader :values, :resource_id
+
+    def initialize(resource_klass, resource_id, values)
+      @resource_id = resource_id
+      @values = values
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.replace_fields(values, context)
+      resource.save
+
+      return JSONAPI::OperationResult.new(:ok, resource)
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::OperationResult.new(e.errors.count == 1 ? e.errors[0].code : :bad_request, nil, e.errors)
+    end
+  end
+
+  class ReplaceHasOneAssociationOperation < Operation
+    attr_reader :resource_id, :association_type, :key_value
+
+    def initialize(resource_klass, resource_id, association_type, key_value)
+      @resource_id = resource_id
+      @key_value = key_value
+      @association_type = association_type
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.replace_has_one_link(@association_type, @key_value, context)
+      resource.save
+
+      return JSONAPI::OperationResult.new(:created, resource)
+    end
+  end
+
+  class CreateHasManyAssociationOperation < Operation
+    attr_reader :resource_id, :association_type, :key_values
+
+    def initialize(resource_klass, resource_id, association_type, key_values)
+      @resource_id = resource_id
+      @key_values = key_values
+      @association_type = association_type
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      @key_values.each do |value|
+        resource.create_has_many_link(@association_type, value, context)
+      end
+
+      return JSONAPI::OperationResult.new(:created, resource)
+    end
+  end
+
+  class RemoveHasManyAssociationOperation < Operation
+    attr_reader :resource_id, :association_type, :associated_key
+
+    def initialize(resource_klass, resource_id, association_type, associated_key)
+      @resource_id = resource_id
+      @associated_key = associated_key
+      @association_type = association_type
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.remove_has_many_link(@association_type, @associated_key, context)
+
+      return JSONAPI::OperationResult.new(:no_content)
+    end
+
+  end
+
+  class RemoveHasOneAssociationOperation < Operation
+    attr_reader :resource_id, :association_type
+
+    def initialize(resource_klass, resource_id, association_type)
+      @resource_id = resource_id
+      @association_type = association_type
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.remove_has_one_link(@association_type, context)
+      resource.save
+
+      return JSONAPI::OperationResult.new(:no_content)
+    end
+  end
+end