standardapi 1.0.23 → 5.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23cfbc54ad1c79fb266ebe6db21945f7688919b4
-  data.tar.gz: b22e6b36685c565bc4b1bbaa550dd89280375a8e
+  metadata.gz: 32b4ca6314bc038faf8b73560d327096f4c4bf53
+  data.tar.gz: 1162cb994c7921a7ffc4eea033a40b0e5f4f50b5
 SHA512:
-  metadata.gz: aaeb76aaa109f63fb0e49b65f67df7cf0b137804e3a59641fb24b63443acf2635eb9dde7a44513e625bf61cff1239ae1b70c14835fe30840b944e1e9f487eb24
-  data.tar.gz: c8553dd7b809e8fec5d9f5f03ea580b8bc2058c12d57d23e6a20226b84da764bdd3a9e0ef9df00d8458e8550617ce218b03f90f0a0cb91eb4fa4613d88555f5a
+  metadata.gz: deaa898296ded369ca9c9b2289eaab9c803977d9f51f5283bf20d546da33b41e9d6fa2c7750195a9c438a87b59434f29fd0eca79421bce83db6774244276456c
+  data.tar.gz: eaeb860e977eee866a9f98ce6ef4b10f697a95a2a6d3e33a286fc390e45102fc287b3139c14ab1a6868b04a115deacabe745c15286f11de76ab86922f6a440c8

data/lib/standard_api/controller.rb

@@ -2,20 +2,20 @@ module StandardAPI
   module Controller
 
     def self.included(klass)
-      klass.hide_action :current_mask
       klass.helper_method :includes, :orders, :model
       klass.append_view_path(File.join(File.dirname(__FILE__), 'views'))
       klass.extend(ClassMethods)
     end
-  
+    
     def ping
-      render :text => 'pong'
+      render plain: 'pong'
     end
 
     def tables
       controllers = Dir[Rails.root.join('app/controllers/*_controller.rb')].map{ |path| path.match(/(\w+)_controller.rb/)[1].camelize+"Controller" }.map(&:safe_constantize)
       controllers.select! { |c| c.ancestors.include?(self.class) && c != self.class }
-      controllers.map!(&:model).compact!.map!(&:table_name)
+      controllers.map!(&:model).compact!
+      controllers.map!(&:table_name)
     
       render json: controllers
     end  
@@ -39,19 +39,43 @@ module StandardAPI
       instance_variable_set("@#{model.model_name.singular}", resources.find(params[:id]))
     end
 
+    def new
+      instance_variable_set("@#{model.model_name.singular}", model.new) if model
+    end
+
     def create
-      instance_variable_set("@#{model.model_name.singular}", model.new(model_params))
-      render :show, status: instance_variable_get("@#{model.model_name.singular}").save ? :created : :bad_request
+      record = model.new(model_params)
+      instance_variable_set("@#{model.model_name.singular}", record)
+      
+      if record.save
+        if request.format == :html
+          redirect_to record
+        else
+          render :show, status: :created
+        end
+      else
+        render :show, status: :bad_request
+      end
     end
 
     def update
-      instance_variable_set("@#{model.model_name.singular}", resources.find(params[:id]))
-      render :show, status: instance_variable_get("@#{model.model_name.singular}").update_attributes(model_params) ? :ok : :bad_request
+      record = resources.find(params[:id])
+      instance_variable_set("@#{model.model_name.singular}", record)
+
+      if record.update_attributes(model_params)
+        if request.format == :html
+          redirect_to record
+        else
+          render :show, status: :ok
+        end
+      else
+        render :show, status: :bad_request
+      end
     end
 
     def destroy
       resources.find(params[:id]).destroy!
-      render nothing: true, status: :no_content
+      head :no_content
     end
 
     # Override if you want to support masking
@@ -75,15 +99,27 @@ module StandardAPI
     end
 
     def model_params
-      params.require(model.model_name.singular).permit(self.send("#{model.model_name.singular}_params"))
+      if self.respond_to?("#{model.model_name.singular}_params", true)
+        params.require(model.model_name.singular).permit(self.send("#{model.model_name.singular}_params"))
+      else
+        []
+      end
     end
 
     def model_includes
-      self.send "#{model.model_name.singular}_includes"
+      if self.respond_to?("#{model.model_name.singular}_includes", true)
+        self.send "#{model.model_name.singular}_includes"
+      else
+        []
+      end
     end
 
     def model_orders
-      self.send "#{model.model_name.singular}_orders"
+      if self.respond_to?("#{model.model_name.singular}_orders", true)
+        self.send "#{model.model_name.singular}_orders"
+      else
+        []
+      end
     end
 
     def excludes_for(klass)
@@ -139,4 +175,4 @@ module StandardAPI
     end
 
   end
-end
+end

data/lib/standard_api/helpers.rb

@@ -1,6 +1,6 @@
 module StandardAPI
   module Helpers
-
+    
     def model_partial(record)
       if lookup_context.exists?(record.model_name.element, record.model_name.plural, true)
         [record.model_name.plural, record.model_name.element].join('/')
@@ -8,6 +8,98 @@ module StandardAPI
         'application/record'
       end
     end
+    
+    def can_cache?(klass, includes)
+      cache_columns = ['cached_at'] + cached_at_columns_for_includes(includes)
+      if (cache_columns - klass.column_names).empty?
+        true
+      else
+        false
+      end
+    end
+    
+    def cache_key(record, includes)
+      timestamp_keys = ['cached_at'] + cached_at_columns_for_includes(includes)
+      if includes.empty?
+        record.cache_key(*timestamp_keys)
+      else
+        timestamp = record.send(:max_updated_column_timestamp, timestamp_keys)
+        "#{record.model_name.cache_key}/#{record.id}-#{digest_hash(sort_hash(includes))}-#{timestamp.utc.to_s(record.cache_timestamp_format)}"
+      end
+    end
+    
+    def can_cache_relation?(klass, relation, subincludes)
+      cache_columns = ["#{relation}_cached_at"] + cached_at_columns_for_includes(subincludes).map {|c| "#{relation}_#{c}"}
+      if (cache_columns - klass.column_names).empty?
+        true
+      else
+        false
+      end
+    end
+    
+    def association_cache_key(record, relation, subincludes)
+      timestamp = ["#{relation}_cached_at"] + cached_at_columns_for_includes(subincludes).map {|c| "#{relation}_#{c}"}
+      timestamp.map! { |col| record.send(col) }
+      timestamp = timestamp.max
+      
+      case association = record.class.reflect_on_association(relation)
+      when ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasAndBelongsToManyReflection, ActiveRecord::Reflection::HasOneReflection, ActiveRecord::Reflection::ThroughReflection
+        "#{record.model_name.cache_key}/#{record.id}/#{includes_to_cache_key(relation, subincludes)}-#{timestamp.utc.to_s(record.cache_timestamp_format)}"
+      when ActiveRecord::Reflection::BelongsToReflection
+        klass = association.options[:polymorphic] ? record.send(association.foreign_type).constantize : association.klass
+        if subincludes.empty?
+          "#{klass.model_name.cache_key}/#{record.send(association.foreign_key)}-#{timestamp.utc.to_s(klass.cache_timestamp_format)}"
+        else
+          "#{klass.model_name.cache_key}/#{record.send(association.foreign_key)}/#{digest_hash(sort_hash(subincludes))}-#{timestamp.utc.to_s(klass.cache_timestamp_format)}"
+        end
+      else
+        raise ArgumentError, 'Unkown association type'
+      end
+    end
+    
+    def cached_at_columns_for_includes(includes)
+      includes.select{|k,v| ![:where, :limit, :order].include?(k.to_sym) }.map { |k, v|
+        ["#{k}_cached_at"] + cached_at_columns_for_includes(v).map{|v| "#{k}_#{v}"}
+      }.flatten
+    end
+    
+    def includes_to_cache_key(relation, subincludes)
+      if subincludes.empty?
+        relation.to_s
+      else
+        "#{relation}-#{digest_hash(sort_hash(subincludes))}"
+      end
+    end
+    
+    def sort_hash(hash)
+      hash.keys.sort.reduce({}) do |seed, key|
+        if seed[key].is_a?(Hash)
+          seed[key] = sort_hash(hash[key])
+        else
+          seed[key] = hash[key]
+        end
+        seed
+      end
+    end
+    
+    def digest_hash(*hashes)
+      hashes.compact!
+      hashes.map! { |h| sort_hash(h) }
+
+      digest =  Digest::MD5.new()
+      hashes.each do |hash|
+        hash.each do |key, value|
+          digest << key.to_s
+          if value.is_a?(Hash)
+            digest << digest_hash(value)
+          else
+            digest << value.to_s
+          end
+        end
+      end
+
+      digest.hexdigest
+    end
 
   end
 end

data/lib/standard_api/includes.rb

@@ -15,10 +15,10 @@ module StandardAPI
       case includes
       when Array
         includes.flatten.compact.each { |v| normalized.merge!(normalize(v)) }
-      when Hash
+      when Hash, ActionController::Parameters
         includes.each_pair do |k, v|
           if ['where', 'order'].include?(k.to_s) # Where and order are not normalized
-            normalized[k] = v
+            normalized[k] = v.to_h
           else
             normalized[k] = normalize(v)
           end
@@ -55,10 +55,7 @@ module StandardAPI
           permitted[k] = sanitize(v, permit[k] || {}, true)
         else
           if [:raise, nil].include?(Rails.configuration.try(:action_on_unpermitted_includes))
-            raise(ActionDispatch::ParamsParser::ParseError.new(<<-ERR.squish, nil))
-              Invalid Include: #{k}"
-              Set config.action_on_unpermitted_includes = :warm to log instead of raise
-            ERR
+            raise ActionController::UnpermittedParameters.new([k])
           else
             Rails.logger.try(:warn, "Invalid Include: #{k}")
           end

data/lib/standard_api/middleware/query_encoding.rb

@@ -0,0 +1,34 @@
+require 'msgpack'
+
+# QueryEncoding middleware intercepts and parsing the query sting as MessagePack
+# if the `Query-Encoding` header is set to `application/msgpack`
+#
+# Usage:
+#
+#   require 'standard_api/middleware/query_encoding'
+#
+# And in the Rails config
+#
+#   config.middleware.insert_after Rack::MethodOverride, StandardAPI::Middleware::QueryEncoding
+module StandardAPI
+  module Middleware
+    class QueryEncoding
+      MSGPACK_MIME_TYPE = "application/msgpack".freeze
+      HTTP_METHOD_OVERRIDE_HEADER = "HTTP_QUERY_ENCODING".freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if !env[Rack::QUERY_STRING].empty? && env[HTTP_METHOD_OVERRIDE_HEADER] == MSGPACK_MIME_TYPE
+          env[Rack::RACK_REQUEST_QUERY_STRING] = env[Rack::QUERY_STRING]
+          env[Rack::RACK_REQUEST_QUERY_HASH] = MessagePack.unpack(CGI.unescape(env[Rack::QUERY_STRING]))
+        end
+
+        @app.call(env)
+      end
+
+    end
+  end
+end

data/lib/standard_api/orders.rb

@@ -9,37 +9,49 @@ module StandardAPI
       permitted = []
 
       case orders
-      when Hash
+      when Hash, ActionController::Parameters
         orders.each do |key, value|
           if key.to_s.count('.') == 1
             key2, key3 = *key.to_s.split('.')
-            permitted = sanitize({key2.to_sym => { key3.to_sym => value } }, permit)
+            permitted << sanitize({key2.to_sym => { key3.to_sym => value } }, permit)
           elsif permit.include?(key.to_s)
-            value = value.symbolize_keys if value.is_a?(Hash)
-            permitted = { key.to_sym => value }
-          elsif permit.find { |x| x.is_a?(Hash) && x.has_key?(key.to_s) }
-            subpermit = permit.find { |x| x.is_a?(Hash) && x.has_key?(key.to_s) }[key.to_s]
+            value = value.symbolize_keys if value.is_a?(Hash) || value.is_a?(ActionController::Parameters)
+            permitted << { key.to_sym => value }
+          elsif permit.find { |x| (x.is_a?(Hash) || x.is_a?(ActionController::Parameters)) && x.has_key?(key.to_s) }
+            subpermit = permit.find { |x| (x.is_a?(Hash) || x.is_a?(ActionController::Parameters)) && x.has_key?(key.to_s) }[key.to_s]
             sanitized_value = sanitize(value, subpermit)
-            permitted = { key.to_sym => sanitized_value }
+            permitted << { key.to_sym => sanitized_value }
           else
-            raise(ActionDispatch::ParamsParser::ParseError.new("Invalid Ordering #{orders.inspect}", nil))
+            raise(ActionController::UnpermittedParameters.new([orders]))
           end
         end
       when Array
-        orders.each { |order| permitted << sanitize(order, permit); }
+        orders.each do |order|
+          order = sanitize(order, permit)
+          if order.is_a?(Array)
+            permitted += order
+          else
+            permitted << order
+          end
+        end
       else
-
         if orders.to_s.count('.') == 1
           key, value = *orders.to_s.split('.')
           permitted = sanitize({key.to_sym => value.to_sym}, permit)
         elsif permit.include?(orders.to_s)
           permitted = orders
         else
-          raise(ActionDispatch::ParamsParser::ParseError.new("Invalid Ordering #{orders.inspect}", nil))
+          raise(ActionController::UnpermittedParameters.new([orders]))
         end
       end
 
-      permitted
+      if permitted.is_a?(Array) && permitted.length == 1
+        permitted.first
+      else
+        permitted
+      end
+
+      # permitted
     end
 
   end

data/lib/standard_api/railtie.rb

@@ -4,6 +4,7 @@ module StandardAPI
     initializer 'standardapi' do
       ActiveSupport.on_load(:action_view) do
         ::ActionView::Base.send :include, StandardAPI::Helpers
+        ::ActionDispatch::Routing::Mapper.send :include, StandardAPI::RouteHelpers
       end
     end
 

data/lib/standard_api/route_helpers.rb

@@ -0,0 +1,26 @@
+module StandardAPI
+  module RouteHelpers
+    
+    # Shorthand for adding resources.
+    #
+    # For example
+    #
+    #   standard_resources :views
+    #
+    # Is equivilent to:
+    #
+    #   resources :api_keys do
+    #     get :schema, on: :collection
+    #     get :calculate, on: :collection
+    #   end
+    def standard_resources(*resources, &block)
+      options = resources.extract_options!.dup
+      
+      resources(*resources, options) do
+        get :schema, on: :collection
+        get :calculate, on: :collection
+      end
+    end
+    
+  end
+end

data/lib/standard_api/test_case/calculate_tests.rb

@@ -7,7 +7,7 @@ module StandardAPI
         m = create_model
         selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
 
-        get :calculate, select: selects, format: 'json'
+        get :calculate, params: {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
@@ -19,9 +19,14 @@ module StandardAPI
         selects = [{ count: :id}, { maximum: :id }, { minimum: :id }, { average: :id }]
         predicate = { id: { gt: m1.id } }
 
-        get :calculate, where: predicate, select: selects, format: 'json'
+        get :calculate, params: {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)
+        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

data/lib/standard_api/test_case/create_tests.rb

@@ -3,12 +3,17 @@ module StandardAPI
     module CreateTests
       extend ActiveSupport::Testing::Declarative
 
+      def setup
+        @request.content_type="application/json"
+        super
+      end
+      
       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'
+          post :create, params: {singular_name => attrs}, format: :json
           assert_response :created
           assert assigns(singular_name)
 
@@ -18,7 +23,11 @@ module StandardAPI
           m = assigns(singular_name)
           view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
             message = "Model / Attribute: #{m.class.name}##{key}"
-            assert_equal normalize_to_json(m, key, attrs[key.to_sym]), json[key.to_s], message
+            if value.is_a?(BigDecimal)
+              assert_equal normalize_to_json(m, key, attrs[key.to_sym]).to_s.to_f, json[key.to_s].to_s.to_f, message
+            else
+              assert_equal normalize_to_json(m, key, attrs[key.to_sym]), json[key.to_s], message
+            end
           end
         end
       end
@@ -28,13 +37,12 @@ module StandardAPI
         create_webmocks(attrs)
 
         assert_difference("#{model.name}.count") do
-          post :create, singular_name => attrs, :format => 'json'
+          post :create, params: {singular_name => attrs}, format: :json
           assert_response :created
           assert assigns(singular_name)
 
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
-
           m = assigns(singular_name).reload
           view_attributes(m).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
             message = "Model / Attribute: #{m.class.name}##{key}"
@@ -44,11 +52,19 @@ module StandardAPI
       end
 
       test '#create.json with invalid attributes' do
+        trait = FactoryGirl.factories[singular_name].definition.defined_traits.any? { |x| x.name.to_s == 'invalid' }
+
+        if !trait
+          Rails.logger.try(:warn, "No invalid trait for #{model.name}. Skipping invalid tests")
+          warn("No invalid trait for #{model.name}. Skipping invalid tests")
+          return
+        end
+
         attrs = attributes_for(singular_name, :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'
+          post :create, params: {singular_name => attrs}, format: :json
           assert_response :bad_request
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
@@ -62,7 +78,7 @@ module StandardAPI
           create_webmocks(attrs)
 
           assert_difference("#{model.name}.count") do
-            post :create, singular_name => attrs, include: includes, :format => 'json'
+            post :create, params: {singular_name => attrs, :include => includes}, format: :json
             assert_response :created
             assert assigns(singular_name)
 

data/lib/standard_api/test_case/destroy_tests.rb

@@ -7,7 +7,7 @@ module StandardAPI
         m = create_model
 
         assert_difference("#{model.name}.count", -1) do
-          delete :destroy, id: m.id, format: 'json'
+          delete :destroy, params: { id: m.id }, format: :json
           assert_response :no_content
           assert_equal '', response.body
         end
@@ -21,7 +21,7 @@ module StandardAPI
         m = create_model
         @controller.current_mask[plural_name] = { id: m.id + 1 }
         assert_raises(ActiveRecord::RecordNotFound) do
-          delete :destroy, id: m.id, format: 'json'
+          delete :destroy, params: { id: m.id }, format: :json
         end
         @controller.current_mask.delete(plural_name)
       end

data/lib/standard_api/test_case/index_tests.rb

@@ -4,41 +4,41 @@ module StandardAPI
       extend ActiveSupport::Testing::Declarative
 
       test '#index.json' do
-        get :index, format: 'json'
+        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 params[:limit]' do
-        get :index, limit: 1, format: 'json'
+        get :index, params: { 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'
+
+        get :index, params: { where: { id: m.id } }, format: :json
         assert_equal [m], assigns(plural_name)
       end
 
       test '#index.json params[:order]' do
         orders.each do |order|
           @controller.instance_variable_set('@orders', nil) # Hack for dealing with caching / multiple request per controller life
-          get :index, order: order, format: 'json'
+          get :index, params: { order: order }, format: :json
           assert_equal model.sort(order).to_sql, assigns(plural_name).to_sql
          end
       end
 
       test '#index.json params[:offset]' do
-        get :index, offset: 13, format: 'json'
+        get :index, params: { offset: 13 }, format: :json
         assert_equal model.offset(13).to_sql, assigns(plural_name).to_sql
       end
 
       test '#index.json params[:include]' do
         travel_to Time.now do
           create_model
-          get :index, include: includes, format: 'json'
+          get :index, params: { include: includes }, format: :json
         
           json = JSON.parse(response.body)[0]
           assert json.is_a?(Hash)
@@ -67,7 +67,7 @@ module StandardAPI
 
               view_attributes(m).each do |key, value|
                 message = "Model / Attribute: #{m.class.name}##{key}"
-                assert_equal m_json[key.to_s], normalize_to_json(m, key, value)
+                assert_equal m_json[key.to_s], normalize_to_json(m, key, value), message
               end
 
             end
@@ -82,7 +82,7 @@ module StandardAPI
 
         m = create_model
         @controller.current_mask[plural_name] = { id: m.id }
-        get :index, format: 'json'
+        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

data/lib/standard_api/test_case/new_tests.rb

@@ -0,0 +1,14 @@
+module StandardAPI
+  module TestCase
+    module NewTests
+      extend ActiveSupport::Testing::Declarative
+
+      test '#new.json' do
+        get :new, format: 'json'
+        assert_response :ok
+        assert assigns(singular_name)
+      end
+
+    end
+  end
+end

data/lib/standard_api/test_case/show_tests.rb

@@ -6,16 +6,15 @@ module StandardAPI
       test '#show.json' do
         m = create_model
 
-        get :show, id: m.id, format: 'json'
+        get :show, params: {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 params[:include]' do
         m = create_model
-        get :show, id: m.id, include: includes, format: 'json'
+        get :show, params: {id: m.id, include: includes}, format: :json
 
         json = JSON.parse(response.body)
         includes.each do |included|
@@ -56,7 +55,7 @@ module StandardAPI
         m = create_model
         @controller.current_mask[plural_name] = { id: m.id + 1 }
         assert_raises(ActiveRecord::RecordNotFound) do
-          get :show, id: m.id, format: 'json'
+          get :show, params: {id: m.id}, format: :json
         end
         @controller.current_mask.delete(plural_name)
       end

data/lib/standard_api/test_case/update_tests.rb

@@ -3,26 +3,46 @@ module StandardAPI
     module UpdateTests
       extend ActiveSupport::Testing::Declarative
 
+      def setup
+        @request.content_type="application/json"
+        super
+      end
+      
       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
+        put :update, params: {:id => m.id, singular_name => attrs}, format: :json
+        assert_response :ok, "Updating #{m.class.name} with #{attrs.inspect}"
 
         view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
           message = "Model / Attribute: #{m.class.name}##{key}"
-          assert_equal normalize_attribute(m, key, attrs[key.to_sym]), value, message
+          if value.is_a?(BigDecimal)
+            assert_equal normalize_attribute(m, key, attrs[key.to_sym]).to_s.to_f, value.to_s.to_f, message
+          else
+            assert_equal normalize_attribute(m, key, attrs[key.to_sym]), value, message
+          end
         end
         assert JSON.parse(@response.body).is_a?(Hash)
       end
 
+      test '#update.html redirects to #show.html' do
+        return if @controller.method(:update).owner != StandardAPI
+        
+        m = create_model
+        attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
+        create_webmocks(attrs)
+
+        put :update, params: {:id => m.id, singular_name => attrs}, format: :html
+        assert_redirected_to m
+      end
+
       test '#update.json with nested attributes' do
         m = create_model
         attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
-        put :update, id: m.id, singular_name => attrs, format: 'json'
+        put :update, params: {:id => m.id, singular_name => attrs}, format: :json
         assert_response :ok
 
         # (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
@@ -34,12 +54,20 @@ module StandardAPI
       end
 
       test '#update.json with invalid attributes' do
+        trait = FactoryGirl.factories[singular_name].definition.defined_traits.any? { |x| x.name.to_s == 'invalid' }
+
+        if !trait
+          Rails.logger.try(:warn, "No invalid trait for #{model.name}. Skipping invalid tests")
+          warn("No invalid trait for #{model.name}. Skipping invalid tests")
+          return
+        end
+
         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
+        put :update, params: {:id => m.id, singular_name => attrs}, format: :json
+        assert_response :bad_request, "Updating #{m.class.name} with invalid attributes #{attrs.inspect}"
         assert JSON.parse(@response.body)['errors']
       end
 
@@ -49,7 +77,7 @@ module StandardAPI
           attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k) }
           create_webmocks(attrs)
 
-          put :update, id: m.id, include: includes, singular_name => attrs, format: 'json'
+          put :update, params: {:id => m.id, :include => includes, singular_name => attrs}, format: :json
 
           json = JSON.parse(response.body)
           includes.each do |included|
@@ -75,7 +103,7 @@ module StandardAPI
 
               view_attributes(m).each do |key, value|
                 message = "Model / Attribute: #{m.class.name}##{key}"
-                assert_equal m_json[key.to_s], normalize_to_json(m, key, value)
+                assert_equal m_json[key.to_s], normalize_to_json(m, key, value), message
               end
 
             end
@@ -91,7 +119,7 @@ module StandardAPI
         m = create_model
         @controller.current_mask[plural_name] = { id: m.id + 1 }
         assert_raises(ActiveRecord::RecordNotFound) do
-          put :update, id: m.id, format: 'json'
+          put :update, params: {id: m.id}, format: 'json'
         end
         @controller.current_mask.delete(plural_name)
       end

data/lib/standard_api/test_case.rb

@@ -1,6 +1,7 @@
 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/new_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'))
@@ -78,12 +79,11 @@ module StandardAPI::TestCase
     
   def normalize_to_json(record, attribute, value)
     value = normalize_attribute(record, attribute, value)
-      
     return nil if value.nil?
 
-    if model.column_types[attribute].is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Decimal)
+    if model.columns_hash[attribute].is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Decimal)
       "#{value.to_f}"
-    elsif model.column_types[attribute].is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
+    elsif value.is_a?(DateTime) #model.columns_hash[attribute].is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
       value.in_time_zone.as_json
     else
       value.as_json
@@ -111,7 +111,7 @@ module StandardAPI::TestCase
           value = m.send(filter[0])
 
           assert_predicate = -> (predicate) {
-            get :index, where: predicate, format: 'json'
+            get :index, params: {where: predicate}, format: 'json'
             assert_equal model.filter(predicate).to_sql, assigns(plural_name).to_sql
           }
 

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

@@ -5,47 +5,55 @@ record.attributes.each do |name, value|
 end
 
 includes.each do |inc, subinc|
-  next if ['where', 'order'].include?(inc.to_s)
-
-  association = record.class.reflect_on_association(inc)
-  if association
-    collection = [:has_many, :has_and_belongs_to_many].include?(association.macro)
-
-    if collection
+  next if [:where, :order, :limit].include?(inc.to_sym)
+  
+  case association = record.class.reflect_on_association(inc)
+  when ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasAndBelongsToManyReflection, ActiveRecord::Reflection::ThroughReflection
+    can_cache = can_cache_relation?(record.class, inc, subinc)
+    json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
       partial = model_partial(association.klass)
       json.set! inc do
-        json.array! record.send(inc), partial: partial, as: partial.split('/').last, locals: { includes: subinc }
+        json.array! record.send(inc).filter(subinc[:where]).limit(subinc[:limit]).sort(subinc[:order]), partial: partial, as: partial.split('/').last, locals: { includes: subinc }
       end
-    else
-
-      if record.send(inc).nil?
+    end
+  
+  when ActiveRecord::Reflection::BelongsToReflection, ActiveRecord::Reflection::HasOneReflection
+    can_cache = can_cache_relation?(record.class, inc, subinc)
+    if association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+      can_cache = can_cache && !record.send(association.foreign_key).nil?
+    end
+    json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
+      value = record.send(inc)
+      if value.nil?
         json.set! inc, nil
       else
-        partial = model_partial(record.send(inc))
+        partial = model_partial(value)
         json.set! inc do
-          json.partial! partial, partial.split('/').last.to_sym => record.send(inc), includes: subinc
+          json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
         end
       end
     end
-
+    
   else
-
-    if record.send(inc).nil?
-      json.set! inc, nil
-    elsif record.send(inc).is_a?(ActiveModel::Model)
-      json.set! inc do
-        partial = model_partial(record.send(inc))
-        json.partial! partial, partial.split('/').last.to_sym => record.send(inc), includes: subinc
+    if record.respond_to?(inc)
+      value = record.send(inc)
+      if value.nil?
+        json.set! inc, nil
+      elsif value.is_a?(ActiveModel::Model)
+        json.set! inc do
+          partial = model_partial(value)
+          json.partial! partial, partial.split('/').last.to_sym => value, includes: subinc
+        end
+      else
+        json.set! inc, value.as_json
       end
-    else
-      # TODO: Test
-      json.set! inc, record.send(inc).as_json
     end
-
   end
   
 end
 
 if !record.errors.blank?
-  json.set! 'errors', record.errors.to_hash
+  errs = record.errors.to_hash
+  errs.default_proc = nil
+  json.set! 'errors', errs
 end

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

@@ -1 +1,12 @@
-json.array! instance_variable_get("@#{model.model_name.plural}"), partial: model_partial(model), as: model_partial(model).split('/').last, includes: includes
+if !includes.empty? && can_cache?(model, includes)
+  partial = model_partial(model)
+  record_name = partial.split('/').last.to_sym
+  locals = { record_name => nil, :includes => includes}
+  
+  json.cache_collection! instance_variable_get("@#{model.model_name.plural}"), key: proc {|record| cache_key(record, includes) } do |record|
+    locals[record_name] = record
+    json.partial! partial, locals
+  end
+else
+  json.array! instance_variable_get("@#{model.model_name.plural}"), partial: model_partial(model), as: model_partial(model).split('/').last, includes: includes
+end

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

@@ -0,0 +1 @@
+json.partial! model_partial(model), model_partial(model).split('/').last.to_sym => instance_variable_get("@#{model.model_name.singular}"), includes: includes

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

@@ -17,7 +17,7 @@ mapping = {
     'double precision' => 'decimal',
     'ltree' => 'string',
     'boolean' => 'boolean',
-    'geometry' => 'hash'
+    'geometry' => 'ewkb'
 }
 
 model.columns.each do |column|

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

@@ -1,2 +1 @@
 json.partial! model_partial(model), model_partial(model).split('/').last.to_sym => instance_variable_get("@#{model.model_name.singular}"), includes: includes
-

data/lib/standard_api.rb

@@ -15,5 +15,5 @@ require 'standard_api/orders'
 require 'standard_api/includes'
 require 'standard_api/controller'
 require 'standard_api/helpers'
+require 'standard_api/route_helpers'
 require 'standard_api/railtie'
-

metadata

@@ -1,71 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: standardapi
 version: !ruby/object:Gem::Version
-  version: 1.0.23
+  version: 5.0.0.rc1
 platform: ruby
 authors:
 - James Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-22 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord-sort
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 5.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
-  name: activerecord-filter
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 5.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: activerecord-sort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: activerecord-filter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: jbuilder
   requirement: !ruby/object:Gem::Requirement
@@ -192,6 +206,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  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:
@@ -206,18 +234,22 @@ files:
 - lib/standard_api/controller.rb
 - lib/standard_api/helpers.rb
 - lib/standard_api/includes.rb
+- lib/standard_api/middleware/query_encoding.rb
 - lib/standard_api/orders.rb
 - lib/standard_api/railtie.rb
+- lib/standard_api/route_helpers.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/new_tests.rb
 - lib/standard_api/test_case/schema_test.rb
 - lib/standard_api/test_case/show_tests.rb
 - lib/standard_api/test_case/update_tests.rb
 - lib/standard_api/views/application/_record.json.jbuilder
 - lib/standard_api/views/application/index.json.jbuilder
+- lib/standard_api/views/application/new.json.jbuilder
 - lib/standard_api/views/application/schema.json.jbuilder
 - lib/standard_api/views/application/show.json.jbuilder
 homepage: https://github.com/waratuman/standardapi
@@ -237,12 +269,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: StandardAPI makes it easy to expose a query interface for your Rails models