backframe 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6893ca50993e2054bfa00298833e7d1d95762c6b
+  data.tar.gz: fcaf54876f10f59cc5e9a8c4306caccfc8e9b5ff
+SHA512:
+  metadata.gz: 1b3d72462843957ff8c6c5b8380f7e29d0b7133d99e79bc737527f56e9dbe985d42818c3dfd13fb2304a3bf028da1085ad7ecfe2dcab9fb33259b5e60bcd6e09
+  data.tar.gz: 68ebc292ef2ea169459348d7c31955976bcdd8432afb30b066ee7d88da46ca9270cb037bfa816ad4997ce7287b52e096772230ee61357bbcb5b2dd752e541743

data/.gitignore

@@ -0,0 +1,10 @@
+.project
+.DS_Store
+.bundle
+coverage
+rdoc
+pkg
+*.gem
+example.rb
+.idea/
+Gemfile.lock

data/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'active_model_serializers', '0.10.0.rc4'
+  gem 'factory_girl'
+  gem 'faker'
+  gem 'kaminari'
+  gem 'rails'
+  gem 'rake'
+  gem 'rspec-rails'
+  gem 'sqlite3'
+end

data/README.md

@@ -0,0 +1,6 @@
+# Backframe
+
+## Development
+
+    bundle install
+    bundle exec rake spec

data/Rakefile

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'rspec/core/rake_task'
+require 'bundler/version'
+require './lib/backframe'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ['--color']
+end
+
+task default: :spec
+
+desc "Build the gem"
+task :build do
+  system "gem build backframe.gemspec"
+end
+
+desc "install the gem"
+task :install do
+  system "gem install backframe-#{Backframe::VERSION}.gem"
+end
+
+desc "Build and release the gem"
+task :release => :build do
+  system "gem push backframe-#{Backframe::VERSION}.gem"
+end

data/backframe.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'backframe/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'backframe'
+  gem.email         = 'hello@thinktopography.com'
+  gem.description   = 'Rails bindings for Reframe'
+  gem.version       = Backframe::VERSION
+  gem.summary       = 'Backframe'
+  gem.authors       = ['Greg Kops', 'Scott Nelson']
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'activesupport', '~> 4.0'
+  gem.add_runtime_dependency 'active_model_serializers', '>= 0.10.0.rc4'
+  gem.add_runtime_dependency 'kaminari', '~> 0.16'
+end

data/lib/backframe/api/adapter.rb

@@ -0,0 +1,49 @@
+module Backframe
+  module API
+    class Adapter < ActiveModel::Serializer::Adapter::Attributes
+      attr_reader :fields, :links
+
+      def initialize(serializer, options = {})
+        super
+        @fields = options[:fields]
+        @links = options[:links]
+      end
+
+      def serializable_hash(options = nil)
+        if paginated?
+          with_pagination_metadata(super)
+        else
+          select_fields(super)
+        end
+      end
+
+      def paginated?
+        serializer.respond_to?(:paginated?) && serializer.paginated?
+      end
+
+      private
+
+      def with_pagination_metadata(records)
+        {
+          records: records.map(&method(:select_fields)),
+          total_records: paginated.total_count,
+          total_pages: paginated.total_pages,
+          current_page: paginated.current_page,
+          links: links
+        }
+      end
+
+      def paginated
+        serializer.object
+      end
+
+      def select_fields(object)
+        if fields.present?
+          object.select { |key, val| fields.include?(key) }
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/backframe/api/errors.rb

@@ -0,0 +1,46 @@
+module Backframe
+  module API
+    module Errors
+      def unauthenticated_request
+        error_response(:unauthenticated, 401)
+      end
+
+      def unauthorized_request
+        error_response(:unauthorized, 403)
+      end
+
+      def resource_not_found
+        error_response(:resource_not_found, 404)
+      end
+
+      def route_not_found
+        error_response(:route_not_found, 404)
+      end
+
+      private
+
+      def error_response(code, status = 500)
+        # TODO: Create generator for translations
+
+        result = {
+          error: {
+            message: I18n.t("backframe.api.#{code}", method: request.method),
+            status: status
+          }
+        }
+
+        render json: result, status: status
+      end
+
+      def resource_error_response(resource, status = 500)
+        result = {
+          message: I18n.t('backframe.api.resource_error', request: request),
+          errors: resource.errors,
+          status: status
+        }
+
+        render json: result, status: status
+      end
+    end
+  end
+end

data/lib/backframe/api/headers.rb

@@ -0,0 +1,9 @@
+module Backframe
+  module API
+    module Headers
+      def set_expiration_header
+        headers['Last-Modified'] = Time.now.httpdate
+      end
+    end
+  end
+end

data/lib/backframe/api/page.rb

@@ -0,0 +1,177 @@
+module Backframe
+  module API
+    module Page
+      DEFAULT_PAGE = 1
+      DEFAULT_PER_PAGE = 100
+
+      def page(collection, serializer = nil)
+        classname = collection.base_class.name+'Serializer'
+        serializer ||= classname.constantize
+        args = params.except(*request.path_parameters.keys)
+        filters = args.except([:sort,:page,:per_page,:fields,:exclude_ids])
+        model = (collection.respond_to?(:klass)) ? collection.klass.name.constantize : collection
+        collection = model.filter(collection, filters) if collection.respond_to?(:filter)
+
+        if args.key?(:sort)
+          args[:sort].split(',').each do |sort|
+            key = (sort[0] == '-') ? sort[1..-1] : sort
+            order = (sort[0] == '-') ? 'desc' : 'asc'
+            collection = model.sort(collection, key, order)
+          end
+        else
+          collection = model.sort(collection)
+        end
+
+        if args.key?(:exclude_ids)
+          ids = args[:exclude_ids].split(',')
+          collection = collection.where('id NOT IN (?)', ids)
+        end
+
+        if args.key?(:all)
+          args[:page] = 1
+          args[:per_page] = 10000
+        end
+
+        args[:page] ||= DEFAULT_PAGE
+        args[:per_page] ||= DEFAULT_PER_PAGE
+
+
+        collection = collection.page(args[:page]).per(args[:per_page])
+        fields = (args.key?(:fields)) ? args[:fields].split(',').map(&:to_sym) : serializer._attributes
+
+        respond_to do |format|
+          format.json {
+            render json: collection,
+                   content_type: 'application/json',
+                   adapter: Backframe::API::Adapter,
+                   fields: fields,
+                   links: pagination_links(collection, args[:per_page], args[:page])
+          }
+          format.csv {
+            content_type = (args.key?(:plain)) ? 'text/plain' : 'text/csv'
+            render :text => collection_to_csv(collection, serializer, fields, ","), :content_type => content_type, :status => 200
+          }
+          format.tsv {
+            content_type = (args.key?(:plain)) ? 'text/plain' : 'text/tab-separated-values'
+            render :text => collection_to_csv(collection, serializer, fields, "\t"), :content_type => content_type, :status => 200
+          }
+          format.xls {
+            content_type = (args.key?(:plain)) ? 'text/xml' : 'application/xls'
+            render :text => collection_to_xls(collection, serializer, fields), :content_type => content_type, :status => 200
+          }
+          format.xlsx {
+            content_type = (args.key?(:plain)) ? 'text/xml' : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            render :text => collection_to_xls(collection, serializer, fields), :content_type => content_type, :status => 200
+          }
+        end
+      end
+
+      def collection_to_csv(collection, serializer, fields, separator)
+        rows = []
+        line = []
+        headers = []
+        collection.each do |record|
+          headers = []
+          line = []
+          serialized = OpenStruct.new(ActiveModel::SerializableResource.new(record).as_json)
+          fields.each do |fullkey|
+            value = serialized
+            fullkey.to_s.split(".").each do |key|
+              if value.respond_to?(key)
+                value = value.send(key)
+                if value.is_a?(Time)
+                  value = value.strftime("%F %T")
+                elsif value.is_a?(Date)
+                  value = value.strftime("%F")
+                elsif value.is_a?(Hash)
+                  value = OpenStruct.new(value)
+                else
+                  value = value.to_s
+                end
+              else
+                value = nil
+              end
+            end
+            if !value.is_a?(OpenStruct)
+              headers << fullkey
+              line << value
+            end
+          end
+          rows << line.join(separator)
+        end
+        rows.unshift(headers.join(separator))
+        rows.join("\n")
+      end
+
+      def collection_to_xls(collection, serializer, fields)
+        rows = []
+        rows << '<?xml version="1.0"?>'
+        rows << '<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel" xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet" xmlns:html="http://www.w3.org/TR/REC-html40">'
+        rows << '<Worksheet ss:Name="Sheet1">'
+        rows << '<Table>'
+        line = []
+        fields.each do |key|
+          line << '<Cell><Data ss:Type="String">'+key+'</Data></Cell>'
+        end
+        rows << "<Row>"+line.join+"</Row>"
+        collection.all.each do |record|
+          line = []
+          serialized = serializer.new(record)
+          fields.each do |fullkey|
+            value = serialized
+            fullkey.to_s.split(".").each do |key|
+              if value.respond_to?(key)
+                value = value.send(key)
+                if value.is_a?(Hash)
+                  value = OpenStruct.new(value)
+                end
+              else
+                value = nil
+              end
+            end
+            if value.is_a?(Numeric)
+              line << '<Cell><Data ss:Type="Number">'+value+'</Data></Cell>'
+            elsif value.is_a?(Time)
+              line << '<Cell><Data ss:Type="String">'+value.strftime("%F %T")+'</Data></Cell>'
+            elsif value.is_a?(Date)
+              line << '<Cell><Data ss:Type="String">'+value.strftime("%F")+'</Data></Cell>'
+            elsif value.is_a?(String)
+              line << '<Cell><Data ss:Type="String">'+value+'</Data></Cell>'
+            else
+              line << '<Cell><Data ss:Type="String"></Data></Cell>'
+            end
+          end
+          rows << "<Row>"+line.join+"</Row>"
+        end
+        rows << '</Table>'
+        rows << '</Worksheet>'
+        rows << '</Workbook>'
+        rows.join("\n")
+      end
+
+      def pagination_links(collection, per_page, page)
+        return {} if collection.total_count.zero?
+        links = {}
+        links[:self] = pagination_link(per_page, page)
+        if collection.next_page.present?
+          links[:next] = pagination_link(per_page, collection.next_page)
+        end
+        if page.to_i < collection.total_pages
+          links[:last] = pagination_link(per_page, collection.total_pages)
+        end
+        if page.to_i > 1
+          links[:first] = pagination_link(per_page, 1)
+        end
+        if collection.prev_page.present?
+          links[:prev] = pagination_link(per_page, collection.prev_page)
+        end
+        links
+      end
+
+      def pagination_link(per_page, page)
+        args = (per_page.to_i != DEFAULT_PER_PAGE) ? "per_page="+per_page.to_s+"&page="+page.to_s : "page="+page.to_s
+        base_api_url+request.path+"?"+args
+      end
+    end
+  end
+end

data/lib/backframe/api.rb

@@ -0,0 +1,35 @@
+require 'active_support'
+require 'active_support/inflector'
+require 'active_model_serializers'
+
+require 'backframe/api/adapter'
+require 'backframe/api/errors'
+require 'backframe/api/headers'
+require 'backframe/api/page'
+
+module Backframe
+  module API
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def acts_as_api
+        include Errors
+        include Headers
+        include Page
+
+        before_action :set_expiration_header
+
+        rescue_from Exceptions::Unauthenticated, :with => :unauthenticated_request
+        rescue_from Exceptions::Unauthorized, :with => :unauthorized_request
+        rescue_from 'ActiveRecord::RecordNotFound', :with => :resource_not_found
+        rescue_from 'ActionController::RoutingError', :with => :route_not_found
+      end
+    end
+
+    included do
+      def base_api_url
+        raise 'must be overridden'
+      end
+    end
+  end
+end

data/lib/backframe/mime.rb

@@ -0,0 +1,11 @@
+module Backframe
+  module Mime
+    extend self
+
+    def register_types
+      ::Mime::Type.register('text/tab-separated-values', :tsv)
+      ::Mime::Type.register('application/vnd.ms-excel', :xls)
+      ::Mime::Type.register('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', :xlsx)
+    end
+  end
+end

data/lib/backframe/resource/actions.rb

@@ -0,0 +1,99 @@
+module Backframe
+  module Resource
+    module Actions
+      module Index
+        def index
+          page(resource.includes(self.class.resource_opts[:include]), nil)
+        end
+      end
+
+      module Create
+        def create
+          @item = resource.new(allowed_params)
+          if @item.save
+            if @item.respond_to?(:activities)
+              Activity.create!(subject: current_user, text: 'created {object1}', object1: @item)
+            end
+
+            render json: @item, status: 201, adapter: Backframe::API::Adapter
+          else
+            resource_error_response(@item, 422)
+          end
+        end
+      end
+
+      module Show
+        def show
+          render json: @item, adapter: Backframe::API::Adapter
+        end
+      end
+
+      module Edit
+        def edit
+          json = {}
+          self.class.resource_opts[:allowed].each do |attribute|
+            if(attribute.is_a?(Hash))
+              attribute.each do |key,val|
+                json[key] = @item.send(key)
+              end
+            else
+              json[attribute] = @item.send(attribute)
+            end
+          end
+          render json: json
+        end
+      end
+
+      module Update
+        def update
+          if @item.update_attributes(allowed_params)
+            if @item.respond_to?(:activities)
+              Activity.create!(subject: current_user, text: 'updated {object1}', object1: @item)
+            end
+
+            render json: @item, adapter: Backframe::API::Adapter
+          else
+            resource_error_response(@item, 422)
+          end
+        end
+      end
+
+      module UpdateAll
+        def update_all
+          records = []
+
+          ActiveRecord::Base.transaction do
+            records = update_all_params.map(&method(:update_record))
+          end
+
+          render json: records, adapter: Backframe::API::Adapter
+        end
+
+        private
+
+        def update_record(attrs)
+          attrs = attrs.with_indifferent_access
+          record = resource.find(attrs[:id])
+          record.attributes = attrs
+          record.save!
+          record
+        end
+
+        def update_all_params
+          permitted = self.class.resource_opts[:allowed] << :id
+          params.permit(records: permitted)[:records] || []
+        end
+      end
+
+      module Destroy
+        def destroy
+          if @item.destroy
+            render nothing: true, status: 204
+          else
+            resource_error_response(@item, 422)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/backframe/resource.rb

@@ -0,0 +1,90 @@
+require 'active_support'
+
+require 'backframe/resource/actions'
+
+module Backframe
+  module Resource
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def acts_as_resource(resource, *args)
+        arguments = (args.present?) ? args[0] : {}
+
+        @resource = resource
+        @resource_opts = arguments
+
+        include Helpers
+
+        member_methods = [:show,:edit,:update,:destroy]
+        if arguments.key?(:has_many)
+          member_methods.concat(arguments[:has_many])
+        end
+
+        if arguments.key?(:only)
+          member_methods = (member_methods.to_set & arguments[:only].to_set).to_a
+        end
+
+        if arguments.key?(:except)
+          member_methods = (member_methods.to_set - arguments[:except].to_set).to_a
+        end
+
+        before_action :load_item, only: member_methods
+
+        include Actions::Index     if include_method?(arguments, :index)
+        include Actions::Create    if include_method?(arguments, :create)
+        include Actions::Show      if include_method?(arguments, :show)
+        include Actions::Edit      if include_method?(arguments, :edit)
+        include Actions::Update    if include_method?(arguments, :update)
+        include Actions::UpdateAll if include_method?(arguments, :update)
+        include Actions::Destroy   if include_method?(arguments, :destroy)
+
+        if arguments.key?(:has_many)
+          arguments[:has_many].each do |association|
+            class_eval <<-EOV
+              def #{association}
+                page(@item.#{association})
+              end
+            EOV
+          end
+        end
+      end
+
+      def resource; @resource; end
+      def resource_opts; @resource_opts; end
+
+      private
+
+      def include_method?(arguments, method)
+        (arguments[:only].present? && arguments[:only].include?(method)) ||
+          (arguments[:except].present? && !arguments[:except].include?(method)) ||
+          (arguments[:only].nil? && arguments[:except].nil?)
+      end
+    end
+  end
+
+  module Helpers
+    def resource
+      self.class.resource.constantize
+    rescue NameError
+      instance_eval self.class.resource
+    end
+
+    def load_item
+      @item = resource.find(params[:id])
+    end
+
+    def allowed_params
+      allowed = params.permit(self.class.resource_opts[:allowed])
+      self.class.resource_opts[:allowed].each do |attribute|
+        if attribute.is_a?(Hash)
+          attribute.each do |key,value|
+            if value.is_a?(Array) && !allowed.key?(key)
+              allowed[key] = []
+            end
+          end
+        end
+      end
+      allowed
+    end
+  end
+end

data/lib/backframe/version.rb

@@ -0,0 +1,3 @@
+module Backframe
+  VERSION = '0.0.0'
+end

data/lib/backframe.rb

@@ -0,0 +1,10 @@
+require 'backframe/api'
+require 'backframe/mime'
+require 'backframe/resource'
+
+module Backframe
+  module Exceptions
+    class Unauthenticated < StandardError; end
+    class Unauthorized < StandardError; end
+  end
+end

data/spec/backframe/api_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe 'Backframe::API', type: :controller do
+  controller do
+    include Backframe::API
+    acts_as_api
+
+    def base_api_url
+      '/example'
+    end
+  end
+
+  describe 'error handlng' do
+    before { get :index }
+
+    context 'resource not found' do
+      controller do
+        def index
+          raise ActiveRecord::RecordNotFound
+        end
+      end
+
+      it 'responds with 404 status' do
+        expect(response.status).to eq 404
+      end
+
+      it 'responds with JSON body' do
+        expect(json_response[:error][:status]).to eq 404
+        expect(json_response[:error][:message]).to be
+      end
+    end
+
+    context 'route not found' do
+      controller do
+        def index
+          raise ActionController::RoutingError, ''
+        end
+      end
+
+      it 'responds with 404 status' do
+        expect(response.status).to eq 404
+      end
+
+      it 'responds with JSON body' do
+        expect(json_response[:error][:status]).to eq 404
+        expect(json_response[:error][:message]).to be
+      end
+    end
+
+    context 'unauthenticated' do
+      controller do
+        def index
+          raise Backframe::Exceptions::Unauthenticated
+        end
+      end
+
+      it 'responds with 401 status' do
+        expect(response.status).to eq 401
+      end
+
+      it 'responds with JSON body' do
+        expect(json_response[:error][:status]).to eq 401
+        expect(json_response[:error][:message]).to be
+      end
+    end
+
+    context 'unauthorized' do
+      controller do
+        def index
+          raise Backframe::Exceptions::Unauthorized
+        end
+      end
+
+      it 'responds with 403 status' do
+        expect(response.status).to eq 403
+      end
+
+      it 'responds with JSON body' do
+        expect(json_response[:error][:status]).to eq 403
+        expect(json_response[:error][:message]).to be
+      end
+    end
+  end
+
+  describe 'headers' do
+    controller do
+      def index
+        render nothing: true
+      end
+    end
+
+    it 'responds with Last-Modified header' do
+      get :index
+
+      # FIXME: Use timecop here
+      expect(response.headers['Last-Modified']).to eq Time.now.httpdate
+    end
+  end
+
+  describe '#page' do
+    let!(:records) { create_list(:example, 10) }
+
+    controller do
+      def index
+        page(Example.all, nil)
+      end
+    end
+
+    it 'responds with 200 status' do
+      get :index, format: :json
+      expect(response.status).to eq 200
+    end
+
+    it 'responds with records' do
+      get :index, format: :json
+      expect(json_response[:records].length).to eq 10
+    end
+
+    it 'responds with links' do
+      get :index, format: :json
+      expect(json_response[:links]).to be
+      expect(json_response[:links][:self]).to eq '/example/anonymous.json?page=1'
+    end
+
+    context 'with pagination params' do
+      before { get :index, page: 2, per_page: 3, format: :json }
+
+      it 'serializes one page of records' do
+        expect(json_response[:records].length).to eq 3
+
+        serialized = serialize(Example.sort(Example)[3]).stringify_keys
+        expect(json_response[:records].first).to eq serialized
+      end
+
+      it 'includes pagination metadata' do
+        expect(json_response[:total_records]).to eq 10
+        expect(json_response[:total_pages]).to eq 4
+        expect(json_response[:current_page]).to eq 2
+      end
+    end
+
+    context 'without pagination params' do
+      before { get :index, format: :json }
+
+      it 'serializes all records' do
+        expect(json_response[:records].length).to eq 10
+
+        serialized = serialize(Example.sort(Example).first).stringify_keys
+        expect(json_response[:records].first).to eq serialized
+      end
+
+      it 'includes pagination metadata' do
+        expect(json_response[:total_records]).to eq 10
+        expect(json_response[:total_pages]).to eq 1
+        expect(json_response[:current_page]).to eq 1
+      end
+    end
+
+    context 'with sort params' do
+      controller do
+        def index
+          page(Example.all)
+        end
+      end
+
+      context 'with single param' do
+        before do
+          create_list(:example, 10)
+          get :index, sort: 'a', format: :json
+        end
+
+        it 'responds with records sorted ascending' do
+          values = json_response[:records].map { |record| record[:a] }
+          expect(values).to eq values.sort
+        end
+      end
+
+      context 'with negated param' do
+        before do
+          create_list(:example, 10)
+          get :index, sort: '-a', format: :json
+        end
+
+        it 'responds with records sorted descending' do
+          values = json_response[:records].map { |record| record[:a] }
+          expect(values).to eq values.sort.reverse
+        end
+      end
+
+      context 'with multiple params' do
+        before do
+          create_list(:example, 10, a: 'a')
+          create_list(:example, 10)
+          get :index, sort: 'a,b', format: :json
+        end
+
+        it 'responds with records sorted by both fields' do
+          values = json_response[:records].map { |record| [record[:a], record[:b]] }
+          expect(values).to eq values.sort
+        end
+      end
+    end
+
+    context 'with field params' do
+      let!(:records) { create_list(:example, 10) }
+
+      before { get :index, fields: 'a,b', format: :json }
+
+      it 'only responds with given fields' do
+        expect(json_response[:records].first).to eq serialize(Example.sort(Example).first, fields: [:a, :b]).stringify_keys
+      end
+    end
+
+    context 'with exclude ids params' do
+      let!(:records) { create_list(:example, 10) }
+      let(:exclude_ids) { records.take(5).map(&:id).join(',') }
+
+      before { get :index, exclude_ids: exclude_ids, format: :json }
+
+      it 'responds with unexcluded records' do
+        expect(json_response[:records].length).to eq 5
+      end
+    end
+  end
+end

data/spec/backframe/resource_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe 'Backframe::Resource', type: :controller do
+  controller do
+    include Backframe::API
+    include Backframe::Resource
+
+    acts_as_api
+    acts_as_resource 'Example', allowed: [:a, :b, :c]
+
+    def base_api_url
+      '/example'
+    end
+  end
+
+  describe '#index' do
+    it 'responds with 200 status' do
+      get :index, format: :json
+      expect(response.status).to eq 200
+    end
+  end
+
+  describe '#create' do
+    let(:params) { attributes_for(:example).merge(format: :json) }
+
+    it 'responds with 201 status' do
+      post :create, params
+      expect(response.status).to eq 201
+    end
+
+    it 'creates record' do
+      expect { post :create, params }.to change { Example.count }.by 1
+    end
+
+    it 'responds with record' do
+      post :create, params
+      expect(json_response).to eq serialize(Example.last).stringify_keys
+    end
+
+    context 'when save fails' do
+      before do
+        allow_any_instance_of(Example).to receive(:save) { false }
+      end
+
+      it 'responds with 422 status' do
+        post :create, params
+        expect(response.status).to eq 422
+      end
+
+      it 'does not create record' do
+        expect { post :create, params }.to change { Example.count }.by 0
+      end
+
+      it 'responds with errors' do
+        post :create, params
+        expect(json_response[:errors]).to be
+        expect(json_response[:message]).to be
+        expect(json_response[:status]).to eq 422
+      end
+    end
+  end
+
+  describe '#show' do
+    let!(:record) { create(:example) }
+
+    it 'responds with 200 status' do
+      get :show, id: record.id
+      expect(response.status).to eq 200
+    end
+
+    it 'responds with record' do
+      get :show, id: record.id
+      expect(json_response).to eq serialize(record).stringify_keys
+    end
+  end
+
+  describe '#edit' do
+    let!(:record) { create(:example) }
+
+    it 'responds with 200 status' do
+      get :edit, id: record.id
+      expect(response.status).to eq 200
+    end
+
+    it 'responds with record' do
+      get :edit, id: record.id
+      expect(json_response).to eq serialize(record).stringify_keys
+    end
+  end
+
+  describe '#update' do
+    let!(:record) { create(:example) }
+    let(:params) { attributes_for(:example).merge(id: record.id) }
+
+    it 'responds with 200 status' do
+      patch :update, params
+      expect(response.status).to eq 200
+    end
+
+    it 'udpates record' do
+      patch :update, params
+      expect(json_response[:a]).to eq params[:a]
+    end
+
+    it 'responds with updated record' do
+      patch :update, params
+      expect(json_response).to eq serialize(record.reload).stringify_keys
+    end
+
+    context 'when save fails' do
+      before do
+        allow_any_instance_of(Example).to receive(:save) { false }
+        patch :update, params
+      end
+
+      it 'responds with 422 status' do
+        expect(response.status).to eq 422
+      end
+
+      it 'does not update record' do
+        expect(record.a).to eq record.reload.a
+      end
+
+      it 'responds with errors' do
+        expect(json_response[:errors]).to be
+        expect(json_response[:message]).to be
+        expect(json_response[:status]).to eq 422
+      end
+    end
+  end
+
+  describe '#update_all' do
+    let!(:records) { create_list(:example, 3) }
+    let(:attrs) { records.map { |record| { id: record.id, a: 'a' } } }
+    let(:params) { ActionController::Parameters.new(records: attrs, format: :json) }
+
+    before do
+      routes.draw { post :update_all, to: 'anonymous#update_all' }
+      post :update_all, params
+    end
+
+    it 'responds with 200 status' do
+      expect(response.status).to eq 200
+    end
+
+    it 'updates all records' do
+      records.each { |record| expect(record.reload.a).to eq 'a' }
+    end
+  end
+
+  describe '#destroy' do
+    let!(:record) { create(:example) }
+
+    it 'responds with 204 status' do
+      delete :destroy, id: record.id
+      expect(response.status).to eq 204
+    end
+
+    it 'deletes record' do
+      expect { delete :destroy, id: record.id }.to change { Example.count }.by(-1)
+    end
+
+    context 'when delete fails' do
+      before do
+        allow_any_instance_of(Example).to receive(:destroy) { false }
+      end
+
+      it 'responds with 422 status' do
+        delete :destroy, id: record.id
+        expect(response.status).to eq 422
+      end
+
+      it 'does not delete record' do
+        expect { delete :destroy, id: record.id }.to change { Example.count }.by 0
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'backframe'
+
+require 'rails'
+require 'action_controller/railtie'
+require 'active_model_serializers'
+require 'active_model_serializers/railtie'
+require 'active_record'
+require 'factory_girl'
+require 'kaminari'
+require 'rspec/rails'
+
+LOGGER = Logger.new('/dev/null')
+
+Rails.logger = LOGGER
+ActiveModelSerializers.logger = LOGGER
+ActiveRecord::Base.logger = LOGGER
+
+DATABASE = {
+  adapter: 'sqlite3',
+  database: ':memory:'
+}
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection(DATABASE)
+
+module Backframe
+  class Application < ::Rails::Application
+    def self.find_root(from)
+      Dir.pwd
+    end
+
+    config.eager_load = false
+    config.secret_key_base = 'secret'
+  end
+end
+
+Backframe::Application.initialize!
+Backframe::Mime.register_types
+
+module Helpers
+  def json_response
+    @json_response ||= JSON.parse(response.body).with_indifferent_access
+  end
+
+  def serialize(value, opts = {})
+    opts[:adapter] ||= Backframe::API::Adapter
+    ActiveModel::SerializableResource.new(value, opts).as_json
+  end
+end
+
+RSpec.configure do |config|
+  config.include Helpers
+  config.include Rails.application.routes.url_helpers
+  config.include FactoryGirl::Syntax::Methods
+
+  config.use_transactional_fixtures = true
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/spec/support/example.rb

@@ -0,0 +1,20 @@
+class Example < ActiveRecord::Base
+  def self.sort(relation, key = nil, order = nil)
+    self._sort(relation, key, order, 'created_at', 'desc', [self])
+  end
+
+  def self._sort(relation, key, order, default_key = 'created_at', default_order = 'desc', included = nil)
+    sortfields = {}
+    included ||= [self]
+    included.each do |model|
+      model.columns.each do |column|
+        sortkey = (model == self) ? column.name : "#{model.table_name.singularize}.#{column.name}"
+        sortfields[sortkey] = "\"#{model.table_name}\".\"#{column.name}\""
+      end
+    end
+
+    key = (key.present? && sortfields.has_key?(key)) ? key : default_key
+    order = (order.present?) ? order : default_order
+    relation.order("#{sortfields[key]} #{order}")
+  end
+end

data/spec/support/example_factory.rb

@@ -0,0 +1,9 @@
+require 'faker'
+
+FactoryGirl.define do
+  factory :example do
+    a { Faker::Lorem.word }
+    b { Faker::Lorem.word }
+    c { Faker::Lorem.word }
+  end
+end

data/spec/support/example_serializer.rb

@@ -0,0 +1,3 @@
+class ExampleSerializer < ActiveModel::Serializer
+  attributes :a, :b, :c
+end

data/spec/support/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define(version: 1) do
+  create_table 'examples' do |t|
+    t.string 'a'
+    t.string 'b'
+    t.string 'c'
+    t.timestamps null: false
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: backframe
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Greg Kops
+- Scott Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0.rc4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0.rc4
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+description: Rails bindings for Reframe
+email: hello@thinktopography.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/vcs.xml"
+- Gemfile
+- README.md
+- Rakefile
+- backframe.gemspec
+- lib/backframe.rb
+- lib/backframe/api.rb
+- lib/backframe/api/adapter.rb
+- lib/backframe/api/errors.rb
+- lib/backframe/api/headers.rb
+- lib/backframe/api/page.rb
+- lib/backframe/mime.rb
+- lib/backframe/resource.rb
+- lib/backframe/resource/actions.rb
+- lib/backframe/version.rb
+- spec/backframe/api_spec.rb
+- spec/backframe/resource_spec.rb
+- spec/spec_helper.rb
+- spec/support/example.rb
+- spec/support/example_factory.rb
+- spec/support/example_serializer.rb
+- spec/support/schema.rb
+homepage: 
+licenses: []
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Backframe
+test_files:
+- spec/backframe/api_spec.rb
+- spec/backframe/resource_spec.rb
+- spec/spec_helper.rb
+- spec/support/example.rb
+- spec/support/example_factory.rb
+- spec/support/example_serializer.rb
+- spec/support/schema.rb