standardapi 6.0.0.26 → 6.1.0

data/lib/standard_api/errors.rb

@@ -2,6 +2,15 @@ module StandardAPI
   class StandardAPIError < StandardError
   end
 
+  class ParameterMissing < StandardAPIError
+    attr_reader :param
+
+    def initialize(param)
+      @param = param
+      super("param is missing or the value is empty: #{param}")
+    end
+  end
+
   class UnpermittedParameters < StandardAPIError
     attr_reader :params
 

data/lib/standard_api/helpers.rb

@@ -1,6 +1,58 @@
 module StandardAPI
   module Helpers
-    
+
+    def preloadables(record, includes)
+      preloads = {}
+
+      includes.each do |key, value|
+        if reflection = record.klass.reflections[key]
+          case value
+          when true
+            preloads[key] = value
+          when Hash, ActiveSupport::HashWithIndifferentAccess
+            if !value.keys.any? { |x| ['when', 'where', 'limit', 'offset', 'order', 'distinct'].include?(x) }
+              if !reflection.polymorphic?
+                preloads[key] = preloadables_hash(reflection.klass, value)
+              end
+            end
+          end
+        end
+      end
+
+      preloads.empty? ? record : record.preload(preloads)
+    end
+
+    def preloadables_hash(klass, iclds)
+      preloads = {}
+
+      iclds.each do |key, value|
+        if reflection = klass.reflections[key]
+          case value
+          when true
+            preloads[key] = value
+          when Hash, ActiveSupport::HashWithIndifferentAccess
+            if !value.keys.any? { |x| ['when', 'where', 'limit', 'offset', 'order', 'distinct'].include?(x) }
+              if !reflection.polymorphic?
+                preloads[key] = preloadables_hash(reflection.klass, value)
+              end
+            end
+          end
+        end
+      end
+
+      preloads
+    end
+
+    def schema_partial(model)
+      path = model.model_name.plural
+
+      if lookup_context.exists?("schema", path, true)
+        [path, "schema"].join('/')
+      else
+        'application/schema'
+      end
+    end
+
     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('/')
@@ -17,7 +69,7 @@ module StandardAPI
         false
       end
     end
-    
+
     def cache_key(record, includes)
       timestamp_keys = ['cached_at'] + record.class.column_names.select{|x| x.ends_with? "_cached_at"}
       if includes.empty?
@@ -27,21 +79,22 @@ module StandardAPI
         "#{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)
+
+    def can_cache_relation?(record, relation, subincludes)
+      return false if record.new_record?
       cache_columns = ["#{relation}_cached_at"] + cached_at_columns_for_includes(subincludes).map {|c| "#{relation}_#{c}"}
-      if (cache_columns - klass.column_names).empty?
+      if (cache_columns - record.class.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 & record.class.column_names).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)}"
@@ -56,13 +109,13 @@ module StandardAPI
         raise ArgumentError, 'Unkown association type'
       end
     end
-    
+
     def cached_at_columns_for_includes(includes)
       includes.select { |k,v| !['when', 'where', 'limit', 'order', 'distinct', 'distinct_on'].include?(k) }.map do |k, v|
         ["#{k}_cached_at"] + cached_at_columns_for_includes(v).map { |v2| "#{k}_#{v2}" }
       end.flatten
     end
-    
+
     def includes_to_cache_key(relation, subincludes)
       if subincludes.empty?
         relation.to_s
@@ -70,7 +123,7 @@ module StandardAPI
         "#{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)
@@ -81,7 +134,7 @@ module StandardAPI
         seed
       end
     end
-    
+
     def digest_hash(*hashes)
       hashes.compact!
       hashes.map! { |h| sort_hash(h) }
@@ -141,4 +194,4 @@ module StandardAPI
     end
 
   end
-end
+end

data/lib/standard_api/includes.rb

@@ -20,6 +20,15 @@ module StandardAPI
           normalized[k] = case k.to_s
           when 'when', 'where', 'order'
             case v
+            when Array
+              v.map do |x|
+                case x
+                when Hash then x.to_h
+                when ActionController::Parameters then x.to_unsafe_h
+                else
+                  x
+                end
+              end
             when Hash then v.to_h
             when ActionController::Parameters then v.to_unsafe_h
             end

data/lib/standard_api/middleware/query_encoding.rb

@@ -13,8 +13,8 @@ require 'msgpack'
 module StandardAPI
   module Middleware
     class QueryEncoding
-      MSGPACK_MIME_TYPE = "application/msgpack".freeze
-      HTTP_METHOD_OVERRIDE_HEADER = "HTTP_QUERY_ENCODING".freeze
+      MSGPACK_MIME_TYPE = "application/msgpack"
+      HTTP_METHOD_OVERRIDE_HEADER = "HTTP_QUERY_ENCODING"
 
       def initialize(app)
         @app = app
@@ -31,4 +31,4 @@ module StandardAPI
 
     end
   end
-end
+end

data/lib/standard_api/railtie.rb

@@ -1,10 +1,21 @@
 module StandardAPI
   class Railtie < ::Rails::Railtie
 
-    initializer 'standardapi' do
+    initializer 'standardapi', :before => :set_autoload_paths do |app|
+      if app.root.join('app', 'controllers', 'acl').exist?
+        ActiveSupport::Inflector.inflections(:en) do |inflect|
+          inflect.acronym 'ACL'
+        end
+
+        app.config.autoload_paths << app.root.join('app', 'controllers', 'acl').to_s
+      end
+
+      ActiveSupport.on_load(:before_configuration) do
+        ::ActionDispatch::Routing::Mapper.send :include, StandardAPI::RouteHelpers
+      end
+
       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

@@ -1,10 +1,10 @@
 module StandardAPI
   module RouteHelpers
-    
+
     # StandardAPI wrapper for ActionDispatch::Routing::Mapper::Resources#resources
     #
     # Includes the following routes
-    #   
+    #
     #   GET /schema
     #   GET /calculate
     #
@@ -20,7 +20,7 @@ module StandardAPI
     #   end
     def standard_resources(*resources, &block)
       options = resources.extract_options!.dup
-      
+
       resources(*resources, options) do
         get :schema, on: :collection
         get :calculate, on: :collection
@@ -33,7 +33,7 @@ module StandardAPI
     # StandardAPI wrapper for ActionDispatch::Routing::Mapper::Resources#resource
     #
     # Includes the following routes
-    #   
+    #
     #   GET /schema
     #   GET /calculate
     #
@@ -49,7 +49,7 @@ module StandardAPI
     #   end
     def standard_resource(*resource, &block)
       options = resource.extract_options!.dup
-      
+
       resource(*resource, options) do
         get :schema, on: :collection
         get :calculate, on: :collection

data/lib/standard_api/test_case.rb

@@ -18,15 +18,14 @@ module StandardAPI::TestCase
       assert_equal(expected, *args)
     end
   end
-      
+
   def self.included(klass)
     [:filters, :orders, :includes].each do |attribute|
       klass.send(:class_attribute, attribute)
     end
 
     begin
-      model_class_name = klass.name.gsub(/ControllerTest$/, '').singularize
-      model_class = model_class_name.constantize
+      model_class = klass.name.gsub(/Test$/, '').constantize.model
 
       klass.send(:filters=, model_class.attribute_names)
       klass.send(:orders=, model_class.attribute_names)
@@ -53,14 +52,14 @@ module StandardAPI::TestCase
     end
   end
 
-  def supports_format(format)
+  def supports_format(format, action=nil)
     count = controller_class.view_paths.count do |path|
-      !Dir.glob("#{path.instance_variable_get(:@path)}/{#{model.name.underscore},application}/**/*.#{format}*").empty?
+      !Dir.glob("#{path.instance_variable_get(:@path)}/{#{model.name.underscore},application}/**/#{action || '*'}.#{format}*").empty?
     end
-    
+
     count > 0
   end
-  
+
   def default_orders
     controller_class.new.send(:default_orders)
   end
@@ -76,7 +75,7 @@ module StandardAPI::TestCase
   def model
     self.class.model
   end
-  
+
   def mask
     {}
   end
@@ -98,11 +97,11 @@ module StandardAPI::TestCase
   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|
       self.class.model.validators_on(attribute)
@@ -122,7 +121,7 @@ module StandardAPI::TestCase
       value
     end
   end
-    
+
   def normalize_to_json(record, attribute, value)
     value = normalize_attribute(record, attribute, value)
     return nil if value.nil?
@@ -138,8 +137,19 @@ module StandardAPI::TestCase
 
   def view_attributes(record)
     return [] if record.nil?
-    record.attributes.select { |x| !@controller.send(:excludes_for, record.class).include?(x.to_sym) }
+    record.attributes.select do |x|
+      !@controller.send(:excludes_for, record.class).include?(x.to_sym)
+    end
+  end
+
+  def update_attributes(record)
+    return [] if record.nil?
+    record.attributes.select do |x|
+      !record.class.readonly_attributes.include?(x.to_s) &&
+      !@controller.send(:excludes_for, record.class).include?(x.to_sym)
+    end
   end
+  alias_method :create_attributes, :update_attributes
 
   module ClassMethods
 
@@ -149,7 +159,7 @@ module StandardAPI::TestCase
 
     def controller_class
       controller_class_name = self.name.gsub(/Test$/, '')
-      controller_class_name.constantize 
+      controller_class_name.constantize
     rescue NameError => e
       raise e if e.message != "uninitialized constant #{controller_class_name}"
     end
@@ -166,7 +176,7 @@ module StandardAPI::TestCase
       return @model if defined?(@model) && @model
 
       klass_name = controller_class.name.gsub(/Controller$/, '').singularize
-        
+
       begin
         @model = klass_name.constantize
       rescue NameError

data/lib/standard_api/test_case/calculate_tests.rb

@@ -12,7 +12,7 @@ module StandardAPI
         create_model
 
         math_column = model.columns.find { |x| CALCULATE_COLUMN_TYPES.include?(x.sql_type) }
-        
+
         if math_column
           column = math_column
           selects = [{ count: column.name }, { maximum: column.name }, { minimum: column.name }, { average: column.name }]
@@ -26,8 +26,14 @@ module StandardAPI
         calculations = @controller.instance_variable_get('@calculations')
         expectations = selects.map { |s| model.send(s.keys.first, column.name) }
         expectations = [expectations] if expectations.length > 1
-        assert_equal expectations,
-          calculations
+
+        if math_column
+          assert_equal expectations.map { |a| a.map { |b| b.round(9) } },
+            calculations.map { |a| a.map { |b| b.round(9) } }
+        else
+          assert_equal expectations.map { |b| b.round(9) },
+            calculations.map { |b| b.round(9) }
+        end
       end
 
       test '#calculate.json params[:where]' do
@@ -35,7 +41,7 @@ module StandardAPI
         create_model
 
         math_column = model.columns.find { |x| CALCULATE_COLUMN_TYPES.include?(x.sql_type) }
-        
+
         if math_column
           column = math_column
           selects = [{ count: column.name}, { maximum: column.name }, { minimum: column.name }, { average: column.name }]

data/lib/standard_api/test_case/create_tests.rb

@@ -22,7 +22,7 @@ module StandardAPI
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
 
-          view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+          create_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
             message = "Model / Attribute: #{m.class.name}##{key}"
             if value.is_a?(BigDecimal)
               assert_equal_or_nil normalize_to_json(m, key, attrs[key.to_sym]).to_s.to_f, json[key.to_s].to_s.to_f, message
@@ -53,9 +53,9 @@ module StandardAPI
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
           m.reload
-          view_attributes(m).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+          create_attributes(m).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
             message = "Model / Attribute: #{m.class.name}##{key}"
-            assert_equal_or_nil normalize_attribute(m, key, attrs[key.to_sym]), value, message
+            assert_equal_or_nil normalize_attribute(m, key, attrs[key.to_sym]), normalize_attribute(m, key, value), message
           end
         end
       end
@@ -64,8 +64,7 @@ module StandardAPI
         trait = FactoryBot.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")
+          skip("No invalid trait for #{model.name}. Skipping invalid tests")
           return
         end
 
@@ -85,15 +84,15 @@ module StandardAPI
       end
 
       test '#create.html' do
-        return unless supports_format(:html)
+        return unless supports_format(:html, :create)
+
+        attrs = attributes_for(singular_name, :nested).select do |k,v|
+          !model.readonly_attributes.include?(k.to_s)
+        end
 
-        attrs = attributes_for(singular_name, :nested).select{ |k,v| !model.readonly_attributes.include?(k.to_s) }
         mask.each { |k, v| attrs[k] = v }
         create_webmocks(attrs)
 
-        file_upload = attrs.any? { |k, v| v.is_a?(Rack::Test::UploadedFile) }
-        as = file_upload ? nil : :json
-
         assert_difference("#{model.name}.count") do
           post resource_path(:create), params: { singular_name => attrs }, as: :html
           assert_response :redirect
@@ -101,13 +100,12 @@ module StandardAPI
       end
 
       test '#create.html with invalid attributes renders edit action' do
-        return unless supports_format(:html)
+        return unless supports_format(:html, :create)
 
         trait = FactoryBot.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")
+          skip("No invalid trait for #{model.name}. Skipping invalid tests")
           return
         end
 
@@ -146,7 +144,7 @@ module StandardAPI
               next if !association
 
               if ['belongs_to', 'has_one'].include?(association.macro.to_s)
-                view_attributes(m.send(included)) do |key, value|
+                create_attributes(m.send(included)) do |key, value|
                   assert_equal json[included.to_s][key.to_s], normalize_to_json(m, key, value)
                 end
               else
@@ -160,7 +158,7 @@ module StandardAPI
                   nil
                 end
 
-                view_attributes(m2).each do |key, value|
+                create_attributes(m2).each do |key, value|
                   message = "Model / Attribute: #{m2.class.name}##{key}"
                   if m_json[key.to_s].nil?
                     assert_nil normalize_to_json(m2, key, value), message