standardapi 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86fbddaa79809d2f3b0f075474e08154e200bbe5
+  data.tar.gz: 82b6a3783e344c8e51b9f1bcc21c1373207365f8
+SHA512:
+  metadata.gz: 8c4e88e5ab6b8409d459130e3536c2c8de33201a09235507222ce11c07c4cdbde14382393d8df2d3cbd7614f8f79b3794ba2a946b32f97b435f1e084ccefc7c3
+  data.tar.gz: b0edbe753c752f464931a4341bb9084577beab115d60c3d356b5a81477953b7f0fe83987f3f3f594714f20b40c3d1ca79042f9551e98ed7d052f896ae63fbe32

data/README.md

@@ -0,0 +1,10 @@
+# standardapi
+StandardAPI makes it easy to expose a query interface for your Rails models
+
+
+required models
+- account { mask }
+- api_keys
+
+# TODO
+- current_mask

data/lib/standard_api.rb

@@ -0,0 +1,158 @@
+require 'rails'
+require 'action_view'
+require 'action_pack'
+require 'action_controller'
+require 'jbuilder'
+require 'jbuilder/railtie'
+require 'active_record/filter'
+require 'active_record/sort'
+
+if !ActionView::Template.registered_template_handler(:jbuilder)
+  ActionView::Template.register_template_handler :jbuilder, JbuilderHandler
+end
+
+module StandardAPI
+
+  def self.included(klass)
+    klass.hide_action :current_mask
+    klass.helper_method :includes, :orders
+    klass.prepend_view_path(File.join(File.dirname(__FILE__), 'standard_api', 'views'))
+  end
+
+  def index
+    @records = resources.limit(params[:limit]).offset(params[:offset]).sort(orders)
+    instance_variable_set("@#{model.model_name.plural}", @records)
+  end
+
+  def calculate
+    @calculations = resources.reorder(nil).pluck(*calculate_selects).map do |c|
+      if c.is_a?(Array)
+        c.map { |v| v.is_a?(BigDecimal) ? v.to_f : v }
+      else
+        c.is_a?(BigDecimal) ? c.to_f : c
+      end
+    end
+    render json: @calculations
+  end
+
+  def show
+    @record = resources.find(params[:id])
+    instance_variable_set("@#{model.model_name.singular}", @record)
+  end
+
+  def create
+    @record = model.new(model_params)
+    instance_variable_set("@#{model.model_name.singular}", @record)
+    render :show, status: @record.save ? :created : :bad_request
+  end
+
+  def update
+    @record = resources.find(params[:id])
+    instance_variable_set("@#{model.model_name.singular}", @record)
+    render :show, status: @record.update_attributes(model_params) ? :ok : :bad_request
+  end
+
+  def destroy
+    resources.find(params[:id]).destroy!
+    render nothing: true, status: :no_content
+  end
+
+  # Override if you want to support masking
+  def current_mask
+    @current_mask ||= {}
+  end
+
+  private
+
+  def model
+    return @model if defined?(@model)
+    @model = self.class.name.sub(/Controller\z/, '').singularize.camelize.constantize
+  end
+
+  def model_params
+    params.require(model.model_name.singular).permit(self.send("#{model.model_name.singular}_params"))
+  end
+
+  def model_includes
+    self.send "#{model.model_name.singular}_includes"
+  end
+
+  def model_orders
+    self.send "#{model.model_name.singular}_orders"
+  end
+
+  def resources
+    model.filter(params[:where]).where(current_mask[model.table_name])
+  end
+
+  # TODO: sanitize includes
+  def includes
+    params[:include] || []
+  end
+
+  # TODO: sanitize orders
+  def orders
+    normalized_order(params[:order])
+  end
+
+  def normalized_order(orderings)
+    return nil if orderings.nil?
+
+    orderings = Array(orderings)
+
+    orderings.map! do |order|
+      if order.is_a?(Symbol) || order.is_a?(String)
+        order = order.to_s
+        if order.index(".")
+          relation, column = order.split('.').map(&:to_sym)
+          { relation => [column] }
+        else
+          order.to_sym
+        end
+      elsif order.is_a?(Hash)
+        normalized_order = {}
+        order.each do |key, value|
+          key = key.to_s
+
+          if key.index(".")
+            relation, column = key.split('.').map(&:to_sym)
+            normalized_order[relation] ||= []
+            normalized_order[relation] << { column => value }
+          elsif value.is_a?(Hash) && value.keys.first.to_s != 'desc' && value.keys.first.to_s != 'asc'
+            normalized_order[key.to_sym] ||= []
+            normalized_order[key.to_sym] << value
+          else
+            normalized_order[key.to_sym] = value
+          end
+        end
+        normalized_order
+      end
+    end
+
+    orderings
+  end
+
+  # Used in #calculate
+  # [{ count: :id }]
+  # [{ count: '*' }]
+  # [{ count: '*', maximum: :id, minimum: :id }]
+  # [{ count: '*' }, { maximum: :id }, { minimum: :id }]
+  # TODO: Sanitize (normalize_select_params(params[:select], model))
+  def calculate_selects
+    return @selects if defined?(@selects)
+
+    functions = ['minimum', 'maximum', 'average', 'sum', 'count']
+    @selects = []
+    Array(params[:select]).each do |select|
+      select.each do |func, column|
+        column = column == '*' ? Arel.star : column.to_sym
+        if functions.include?(func.to_s.downcase)
+          @selects << (model.arel_table[column.to_sym].send(func).to_sql)
+        end
+      end
+    end
+
+    @selects
+  end
+
+end

data/lib/standard_api/test_case.rb

@@ -0,0 +1,140 @@
+require 'active_support/test_case'
+
+require File.expand_path(File.join(__FILE__, '../test_case/calculate_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/create_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/destroy_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/index_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/show_tests'))
+require File.expand_path(File.join(__FILE__, '../test_case/update_tests'))
+
+module StandardAPI::TestCase
+      
+  def self.included(klass)
+    model_class_name = klass.controller_class.name.gsub(/Controller$/, '').singularize
+
+    [:filters, :orders, :includes].each do |attribute|
+      klass.send(:class_attribute, attribute)
+    end
+    if defined?(model_class_name.constantize)
+      model_class = model_class_name.constantize
+      klass.send(:filters=, model_class.attribute_names)
+      klass.send(:orders=, model_class.attribute_names)
+      klass.send(:includes=, model_class.reflect_on_all_associations.map(&:name))
+    end
+    
+    klass.extend(ClassMethods)
+
+    klass.controller_class.action_methods.each do |action|
+      klass.include("StandardAPI::TestCase::#{action.capitalize}Tests".constantize)
+    end
+  end
+
+  def model
+    self.class.model
+  end
+
+  def create_model(attrs={})
+    create(model.name.underscore, attrs)
+  end
+
+  def singular_name
+    model.model_name.singular
+  end
+  
+  def plural_name
+    model.model_name.plural
+  end
+    
+  def create_webmocks(attributes)
+    attributes.each do |attribute, value|
+      validators = self.class.model.validators_on(attribute)
+    end
+  end
+    
+  def normalize_attribute(attribute, value)
+    validators = self.class.model.validators_on(attribute)
+    value
+  end
+    
+  def normalize_to_json(attribute, value)
+    value = normalize_attribute(attribute, value)
+      
+    return nil if value.nil?
+
+    if model.column_types[attribute].is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Decimal)
+      "#{value}"
+    elsif model.column_types[attribute].is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
+      value.to_datetime.utc.iso8601.gsub(/\+00:00$/, 'Z')
+    else
+      value
+    end
+  end
+
+  module ClassMethods
+    
+    def include_filter_tests
+      model.instance_variable_get('@filters').each do |filter|
+        next if filter[1].is_a?(Proc) # Custom filter
+        next if model.reflect_on_association(filter[0]) # TODO: Relation Filter Tests
+
+        define_method("test_model_filter_#{filter[0]}") do
+          m = create_model
+          value = m.send(filter[0])
+
+          assert_predicate = -> (predicate) {
+            get :index, where: predicate, format: 'json'
+            assert_equal model.filter(predicate).to_sql, assigns(plural_name).to_sql
+          }
+
+          # TODO: Test array
+          case model.columns_hash[filter[0].to_s].type
+          when :jsonb, :json # JSON
+            assert_predicate.call({ filter[0] => value })
+          else
+            case value
+            when Array
+              assert_predicate.call({ filter[0] => value }) # Overlaps
+              assert_predicate.call({ filter[0] => value[0] }) # Contains
+            else
+              assert_predicate.call({ filter[0] => value }) # Equality
+              assert_predicate.call({ filter[0] => { gt: value } }) # Greater Than
+              assert_predicate.call({ filter[0] => { greater_than: value } })
+              assert_predicate.call({ filter[0] => { lt: value } }) # Less Than
+              assert_predicate.call({ filter[0] => { less_than: value } })
+              assert_predicate.call({ filter[0] => { gte: value } }) # Greater Than or Equal To
+              assert_predicate.call({ filter[0] => { gteq: value } })
+              assert_predicate.call({ filter[0] => { greater_than_or_equal_to: value } })
+              assert_predicate.call({ filter[0] => { lte: value } }) # Less Than or Equal To
+              assert_predicate.call({ filter[0] => { lteq: value } })
+              assert_predicate.call({ filter[0] => { less_than_or_equal_to: value } })
+            end
+          end
+        end
+      end
+    end
+
+    def model=(val)
+      @model = val
+    end
+
+    def model
+      return @model if defined?(@model) && @model
+
+      klass_name = controller_class.name.gsub(/Controller$/, '').singularize
+        
+      begin
+        @model = klass_name.constantize
+      rescue NameError
+        raise e unless e.message =~ /uninitialized constant #{klass_name}/
+      end
+
+      if @model.nil?
+        raise "@model is nil: make sure you set it in your test using `self.model = ModelClass`."
+      else
+        @model
+      end
+    end
+
+  end
+
+end

data/lib/standard_api/test_case/calculate_tests.rb

@@ -0,0 +1,44 @@
+module StandardAPI
+  module TestCase
+    module CalculateTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#calculate.json' do
+        m = create_model
+        selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
+
+        get :calculate, select: selects, format: 'json'
+        assert_response :ok
+        assert_equal [[model.count(:id), model.maximum(:id), model.minimum(:id), model.average(:id).to_f]], assigns(:calculations)
+      end
+
+      test '#calculate.json params[:where]' do
+        m1 = create_model
+        m2 = create_model
+
+        selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
+        predicate = { id: { gt: m1.id } }
+
+        get :calculate, where: predicate, select: selects, format: 'json'
+        assert_response :ok
+        assert_equal [[model.filter(predicate).count(:id), model.filter(predicate).maximum(:id), model.filter(predicate).minimum(:id), model.filter(predicate).average(:id).to_f]], assigns(:calculations)
+      end
+
+      test '#calculate.json mask' do
+        m = create_model
+        @controller.current_mask[plural_name] = { id: m.id + 100 }
+        selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
+        get :calculate, select: selects, format: 'json'
+        assert_response :ok
+        assert_equal [[0, nil, nil, nil]], assigns(:calculations)
+        @controller.current_mask.delete(plural_name)
+      end
+
+      test 'route to #calculate.json' do
+        assert_routing "/#{plural_name}/calculate", path_with_action('calculate')
+        assert_recognizes(path_with_action('calculate'), "/#{plural_name}/calculate")
+      end
+        
+    end
+  end
+end

data/lib/standard_api/test_case/create_tests.rb

@@ -0,0 +1,71 @@
+module StandardAPI
+  module TestCase
+    module CreateTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#create.json' do
+        attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
+        create_webmocks(attrs)
+
+        assert_difference("#{model.name}.count") do
+          post :create, singular_name => attrs, :format => 'json'
+          assert_response :created
+          assert assigns(singular_name)
+
+          json = JSON.parse(response.body)
+          assert json.is_a?(Hash)
+          (model.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
+            assert_equal normalize_to_json(test_key, attrs[test_key.to_sym]), json[test_key]
+          end
+        end
+      end
+
+      test '#create.json with invalid attributes' do
+        attrs = attributes_for(singular_name, :nested, :invalid).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
+        create_webmocks(attrs)
+
+        assert_difference("#{model.name}.count", 0) do
+          post :create, singular_name => attrs, :format => 'json'
+          assert_response :bad_request
+          json = JSON.parse(response.body)
+          assert json.is_a?(Hash)
+          assert json['errors']
+        end
+      end
+
+      test '#create.json params[:include]' do
+        attrs = attributes_for(singular_name, :nested).select{ |k,v| !model.readonly_attributes.include?(k.to_s) }
+        create_webmocks(attrs)
+
+        assert_difference("#{model.name}.count") do
+          post :create, singular_name => attrs, include: includes, :format => 'json'
+          assert_response :created
+          assert assigns(singular_name)
+
+          json = JSON.parse(response.body)
+          assert json.is_a?(Hash)
+          includes.each do |included|
+            assert json.key?(included.to_s), "#{included.inspect} not included in response"
+
+            association = assigns(:record).class.reflect_on_association(included)
+            if ['belongs_to', 'has_one'].include?(association.macro)
+              assigns(:record).send(included).attributes do |key, value|
+                assert_equal json[included.to_s][key.to_s], value
+              end
+            else
+              assigns(:record).send(included).first.attributes.each do |key, value|
+                assert_equal json[included.to_s][0][key.to_s], value
+              end
+            end
+          end
+        end
+      end
+
+      test 'route to #create.json' do
+        assert_routing({ method: :post, path: "/#{plural_name}" }, path_with_action('create'))
+        assert_recognizes(path_with_action('create'), { method: :post, path: "/#{plural_name}" })
+      end
+        
+    end
+  end
+end

data/lib/standard_api/test_case/destroy_tests.rb

@@ -0,0 +1,32 @@
+module StandardAPI
+  module TestCase
+    module DestroyTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#destroy.json' do
+        m = create_model
+
+        assert_difference("#{model.name}.count", -1) do
+          delete :destroy, id: m.id, format: 'json'
+          assert_response :no_content
+          assert_equal '', response.body
+        end
+      end
+
+      test '#destroy.json mask' do
+        m = create_model
+        @controller.current_mask[plural_name] = { id: m.id + 1 }
+        assert_raises(ActiveRecord::RecordNotFound) do
+          delete :destroy, id: m.id, format: 'json'
+        end
+        @controller.current_mask.delete(plural_name)
+      end
+
+      test 'route to #destroy.json' do
+        assert_routing({ method: :delete, path: "/#{plural_name}/1" }, path_with_action('destroy', id: '1'))
+        assert_recognizes(path_with_action('destroy', id: '1'), { method: :delete, path: "/#{plural_name}/1" })
+      end
+
+    end
+  end
+end

data/lib/standard_api/test_case/index_tests.rb

@@ -0,0 +1,68 @@
+module StandardAPI
+  module TestCase
+    module IndexTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#index.json' do
+        get :index, format: 'json'
+        assert_response :ok
+        assert_template :index
+        assert_equal model.all.map(&:id).sort, assigns(plural_name).map(&:id).sort
+        assert JSON.parse(response.body).is_a?(Array)
+      end
+
+      test '#index.json mask' do
+        m = create_model
+        @controller.current_mask[plural_name] = { id: m.id }
+        get :index, format: 'json'
+        assert_equal model.where(id: m.id).to_sql, assigns(plural_name).to_sql
+        @controller.current_mask.delete(plural_name)
+      end
+
+      test '#index.json params[:limit]' do
+        get :index, limit: 1, format: 'json'
+        assert_equal model.limit(1).to_sql, assigns(plural_name).to_sql
+      end
+
+      test '#index.json params[:where]' do
+        m = create_model
+        get :index, where: { id: m.id }, format: 'json'
+        assert_equal [m], assigns(plural_name)
+      end
+
+      test '#index.json params[:order]' do
+        orders.each do |order|
+          if order.is_a?(Hash)
+            order.values.last.each do |o|
+              get :index, order: {order.keys.first => o}, format: 'json'
+              assert_equal model.sort(order.keys.first => o).to_sql, assigns(plural_name).to_sql
+            end
+          else
+            get :index, order: order, format: 'json'
+            assert_equal model.sort(order).to_sql, assigns(:records).to_sql
+          end
+        end
+      end
+
+      test '#index.json params[:offset]' do
+        get :index, offset: 13, format: 'json'
+        assert_equal model.offset(13).to_sql, assigns(:records).to_sql
+      end
+
+      test '#index.json params[:include]' do
+        create_model
+
+        includes.each do |included|
+          get :index, include: [included], format: 'json'
+          assert JSON.parse(response.body)[0].key?(included.to_s), "#{included.inspect} not included in response"
+        end
+      end
+
+      test 'route to #index.json' do
+        assert_routing "/#{plural_name}", path_with_action('index')
+        assert_recognizes path_with_action('index'), "/#{plural_name}"
+      end
+      
+    end
+  end
+end

data/lib/standard_api/test_case/show_tests.rb

@@ -0,0 +1,53 @@
+module StandardAPI
+  module TestCase
+    module ShowTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#show.json' do
+        m = create_model
+
+        get :show, id: m.id, format: 'json'
+        assert_response :ok
+        assert_template :show
+        assert_equal m, assigns(singular_name)
+        assert JSON.parse(response.body).is_a?(Hash)
+      end
+
+      test '#show.json mask' do
+        m = create_model
+        @controller.current_mask[plural_name] = { id: m.id + 1 }
+        assert_raises(ActiveRecord::RecordNotFound) do
+          get :show, id: m.id, format: 'json'
+        end
+        @controller.current_mask.delete(plural_name)
+      end
+
+      test '#show.json params[:include]' do
+        m = create_model(:nested)
+        get :show, id: m.id, include: includes, format: 'json'
+
+        json = JSON.parse(response.body)
+        includes.each do |included|
+          assert json.key?(included.to_s), "#{included.inspect} not included in response"
+
+          association = assigns(:record).class.reflect_on_association(included)
+          if ['belongs_to', 'has_one'].include?(association.macro)
+            assigns(:record).send(included).attributes do |key, value|
+              assert_equal json[included.to_s][key.to_s], value
+            end
+          else
+            assigns(:record).send(included).first.attributes.each do |key, value|
+              assert_equal json[included.to_s][0][key.to_s], value
+            end
+          end
+        end
+      end
+
+      test 'route to #show.json' do
+        assert_routing "/#{plural_name}/1", path_with_action('show', id: '1')
+        assert_recognizes(path_with_action('show', id: '1'), "/#{plural_name}/1")
+      end
+
+    end
+  end
+end

data/lib/standard_api/test_case/update_tests.rb

@@ -0,0 +1,72 @@
+module StandardAPI
+  module TestCase
+    module UpdateTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#update.json' do
+        m = create_model
+        attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
+        create_webmocks(attrs)
+
+        put :update, id: m.id, singular_name => attrs, format: 'json'
+        assert_response :ok
+
+        (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
+          assert_equal normalize_attribute(test_key, attrs[test_key.to_sym]), m.reload.send(test_key)
+        end
+        assert JSON.parse(@response.body).is_a?(Hash)
+      end
+
+      test '#update.json with invalid attributes' do
+        m = create_model
+        attrs = attributes_for(singular_name, :invalid).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
+        create_webmocks(attrs)
+
+        put :update, id: m.id, singular_name => attrs, format: 'json'
+        assert_response :bad_request
+        assert JSON.parse(@response.body)['errors']
+      end
+
+      test '#update.json params[:include]' do
+        m = create_model(:nested)
+        attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k) }
+        create_webmocks(attrs)
+
+        put :update, id: m.id, include: includes, singular_name => attrs, format: 'json'
+
+        json = JSON.parse(response.body)
+        includes.each do |included|
+          assert json.key?(included.to_s), "#{included.inspect} not included in response"
+
+          association = assigns(:record).class.reflect_on_association(included)
+          if ['belongs_to', 'has_one'].include?(association.macro)
+            assigns(:record).send(included).attributes do |key, value|
+              assert_equal json[included.to_s][key.to_s], value
+            end
+          else
+            assigns(:record).send(included).first.attributes.each do |key, value|
+              assert_equal json[included.to_s][0][key.to_s], value
+            end
+          end
+        end
+      end
+
+      test '#update.json mask' do
+        m = create_model
+        @controller.current_mask[plural_name] = { id: m.id + 1 }
+        assert_raises(ActiveRecord::RecordNotFound) do
+          put :update, id: m.id, format: 'json'
+        end
+        @controller.current_mask.delete(plural_name)
+      end
+
+      test 'route to #update.json' do
+        assert_routing({ method: :put, path: "#{plural_name}/1" }, path_with_action('update', id: '1'))
+        assert_recognizes(path_with_action('update', id: '1'), { method: :put, path: "/#{plural_name}/1" })
+        assert_routing({ method: :patch, path: "/#{plural_name}/1" }, path_with_action('update', id: '1'))
+        assert_recognizes(path_with_action('update', id: '1'), { method: :patch, path: "/#{plural_name}/1" })
+      end
+
+    end
+  end
+end

data/lib/standard_api/views/application/_model.json.jbuilder

@@ -0,0 +1,17 @@
+model.attributes.each do |name, value|
+  json.set! name, value
+end
+
+includes.each do |inc|
+  if model.class.reflect_on_association(inc).klass.is_a?(ActiveModel)
+    json.set! inc do
+      json.partial! 'action_controller/standard_api/_model', locals: { model: model.send(inc) }
+    end
+  else
+    json.set! inc, model.send(inc)
+  end
+end
+
+if model.errors
+  json.set! 'errors', model.errors.to_h
+end

data/lib/standard_api/views/application/index.json.jbuilder

@@ -0,0 +1,3 @@
+models = @records if !models
+
+json.array! models, partial: 'application/model', as: :model, includes: includes

data/lib/standard_api/views/application/show.json.jbuilder

@@ -0,0 +1,3 @@
+model = @record if !model
+
+json.partial! 'application/model', model: model, includes: includes

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: standardapi
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- James Bracy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord-sort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-filter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: jbuilder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: faker
+  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: StandardAPI makes it easy to expose a query interface for your Rails
+  models
+email:
+- waratuman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/standard_api.rb
+- lib/standard_api/test_case.rb
+- lib/standard_api/test_case/calculate_tests.rb
+- lib/standard_api/test_case/create_tests.rb
+- lib/standard_api/test_case/destroy_tests.rb
+- lib/standard_api/test_case/index_tests.rb
+- lib/standard_api/test_case/show_tests.rb
+- lib/standard_api/test_case/update_tests.rb
+- lib/standard_api/views/application/_model.json.jbuilder
+- lib/standard_api/views/application/index.json.jbuilder
+- lib/standard_api/views/application/show.json.jbuilder
+homepage: https://github.com/waratuman/standardapi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+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.5
+signing_key: 
+specification_version: 4
+summary: StandardAPI makes it easy to expose a query interface for your Rails models
+test_files: []