model-api 0.8.3

data/lib/model-api/bypass_parse_middleware.rb

@@ -0,0 +1,32 @@
+module ModelApi
+  class BypassParseMiddleware
+    def initialize(app)
+      @app = app
+      @api_roots = nil
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+      unless @api_roots.present?
+        options = Rails.application.config.class.class_variable_get(:@@options)
+        options ||= {}
+        @api_roots = options[:api_middleware_root_paths] || ['api']
+        @api_roots = [@api_roots] unless @api_roots.is_a?(Array)
+        @api_roots = @api_roots.map { |path| path.starts_with?('/') ? path : "/#{path}" }
+      end
+      @api_roots.each do |path|
+        next unless env['REQUEST_PATH'].to_s.starts_with?(path)
+        api_format = nil
+        if request.content_type.to_s.downcase.ends_with?('json')
+          api_format = :json
+        elsif request.content_type.to_s.downcase.ends_with?('xml')
+          api_format = :xml
+        end
+        env['action_dispatch.request.content_type'] = 'application/x-api'
+        env['API_CONTENT_TYPE'] = api_format
+        break
+      end
+      @app.call(env)
+    end
+  end
+end

data/lib/model-api/hash_metadata.rb

@@ -0,0 +1,48 @@
+module ModelApi
+  class HashMetadata
+    class << self
+      def process_metadata(type, obj, args)
+        type = type.to_sym
+        instance_var = :"@api_#{type}_metadata"
+        metadata = obj.instance_variable_get(instance_var) || {}
+        if args.present?
+          if args.size == 1 && args[0].is_a?(Hash)
+            new_metadata = args[0].symbolize_keys
+          elsif args.size == 1 && args[0].is_a?(Array)
+            new_metadata = Hash[args[0].map { |key| [key.to_sym, {}] }]
+          else
+            new_metadata = Hash[args.map { |key| [key.to_sym, {}] }]
+          end
+          new_metadata.symbolize_keys.each do |key, item_metadata|
+            if (existing_item_metadata = metadata[key]).is_a?(Hash)
+              existing_item_metadata.merge!(item_metadata)
+            else
+              item_metadata[:key] = key
+              metadata[key] = item_metadata
+            end
+          end
+          obj.instance_variable_set(instance_var, metadata)
+        end
+        metadata.dup
+      end
+
+      def merge_superclass_metadata(type, sc, metadata)
+        metadata_method = :"api_#{type}"
+        return metadata if sc == ActiveRecord::Base || !sc.respond_to?(metadata_method)
+        superclass_metadata = sc.send(metadata_method)
+        merged_metadata = {}
+        superclass_metadata.each do |item, item_metadata|
+          merged_metadata[item] = item_metadata.dup
+        end
+        metadata.each do |key, item_metadata|
+          if (existing_item_metadata = merged_metadata[key]).is_a?(Hash)
+            existing_item_metadata.merge!(item_metadata)
+          else
+            merged_metadata[key] = item_metadata
+          end
+        end
+        merged_metadata
+      end
+    end
+  end
+end

data/lib/model-api/model.rb

@@ -0,0 +1,49 @@
+module ModelApi
+  module Model
+    module ClassMethods
+      def api_model(*args)
+        metadata = ModelApi::SimpleMetadata.process_metadata(:model, self, args)
+        ModelApi::SimpleMetadata.merge_superclass_metadata(:model, superclass, metadata,
+            exclude_keys: [:alias])
+      end
+
+      def api_attributes(*args)
+        metadata = ModelApi::HashMetadata.process_metadata(:attributes, self, args)
+        metadata = ModelApi::HashMetadata.merge_superclass_metadata(:attributes, superclass, metadata)
+        if args.present?
+          id_attrs = []
+          metadata.each { |attr, attr_metadata| id_attrs << attr if attr_metadata[:id] }
+          if id_attrs.present?
+            id_attrs = id_attrs.map(&:to_sym)
+            existing_id_attrs = (api_model[:id_attributes] || []).map(&:to_sym)
+            if (id_attrs - existing_id_attrs).present?
+              api_model id_attributes: (id_attrs - existing_id_attrs).uniq
+            end
+          end
+        end
+        if self < ActiveRecord::Base && (args.present? ||
+            !self.instance_variable_get(:@api_attrs_characterized))
+          metadata.each do |attr, attr_metadata|
+            if (assoc = self.reflect_on_association(attr)).present?
+              attr_metadata[:type] = :association
+              attr_metadata[:association] = assoc
+            else
+              attr_metadata[:type] = :attribute
+            end
+          end
+          self.instance_variable_set(:@api_attrs_characterized, true)
+        end
+        metadata
+      end
+
+      def api_links(*args)
+        metadata = ModelApi::HashMetadata.process_metadata(:links, self, args)
+        ModelApi::HashMetadata.merge_superclass_metadata(:links, superclass, metadata)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/model-api/not_found_exception.rb

@@ -0,0 +1,10 @@
+module ModelApi
+  class NotFoundException < Exception
+    attr_reader :field
+
+    def initialize(field = nil, message = nil)
+      super(message)
+      @field = field
+    end
+  end
+end

data/lib/model-api/open_api_extensions.rb

@@ -0,0 +1,287 @@
+module ModelApi
+  module OpenApiExtensions
+    module ClassMethods
+      def add_open_api_action(action, operation, opts = {})
+        return unless respond_to?(:open_api_action) # Must have open_api gem installed
+        opts = opts.merge(action: action, operation: operation)
+        if ENV['ADMIN'].present? && ENV['ADMIN'].to_s != '0'
+          opts[:admin_content] = true
+        elsif opts[:admin_only]
+          open_api_action action, hidden: :true
+          return
+        end
+        open_api_spec = {}
+        open_api_spec[:description] = opts[:description] if opts.include?(:description)
+        response_class = opts[:response] || model_class
+        if operation == :index || opts[:collection]
+          response = Utils.define_api_collection_response(self, response_class, opts)
+          open_api_spec[:query_string] = Utils.filter_and_sort_params(self, response_class, opts)
+        else
+          response = Utils.define_api_response(self, response_class,
+              opts.merge(operation: :show))
+        end
+        open_api_spec[:responses] = { 200 => { schema: response } } if response.present?
+        if [:create, :update, :patch].include?(operation)
+          payload = opts[:payload] || model_class
+          if payload.present?
+            open_api_spec[:body] = { description: 'Payload', schema: Utils.define_open_api_object(
+                self, payload, opts.merge(object_context: :payload)) }
+          end
+        end
+        open_api_action action, open_api_spec
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    class Utils
+      class << self
+        def define_api_response(controller_class, model_class, opts = {})
+          object_name = define_open_api_object(controller_class, model_class, opts)
+          return nil unless object_name.present?
+          wrapper_object_name = "#{object_name}:response"
+          response_object_metadata = { type: :object, required: true }
+          response_object_metadata[:'$ref'] = object_name if object_name.present?
+          controller_class.send(:open_api_object, wrapper_object_name,
+              successful: { type: :boolean, required: true,
+                  description: 'Returns true if successfully processed; otherwise false' },
+              status: { type: :string, required: true, description: 'HTTP status' },
+              statusCode: { type: :integer, required: true,
+                  description: 'Numeric HTTP status code' },
+              ModelApi::Utils.ext_attr(opts[:root] || ModelApi::Utils.model_name(model_class).singular) =>
+                  response_object_metadata)
+          wrapper_object_name
+        end
+
+        def filter_and_sort_params(controller_class, model_class, opts = {})
+          params = opts[:parameters] || {}
+          opts = opts.merge(attr_types: attr_types_from_columns(model_class))
+          attr_prefix = opts[:attr_prefix]
+          sort_attrs = []
+
+          filter_metadata = ModelApi::Utils.filtered_ext_attrs(model_class, :filter, opts)
+          filter_metadata.each do |attr, attr_metadata|
+            if attr_metadata[:type] == :association
+              next unless (assoc = attr_metadata[:association]).present? &&
+                  assoc.respond_to?(:klass)
+              assoc_params = filter_and_sort_params(controller_class, assoc.klass,
+                  opts.merge(attr_prefix: "#{attr}."))
+              sort_attrs += assoc_params.delete(:sort_by) || []
+              assoc_params.each { |assoc_attr, property_hash| params[assoc_attr] ||= property_hash }
+            else
+              property_hash = open_api_attr_hash(controller_class, model_class, attr, attr_metadata,
+                  opts)
+              property_hash.merge!(
+                  description: filter_description(attr_prefix, attr, property_hash, attr_metadata),
+                  required: false)
+              next if property_hash.include?(:'$ref')
+              params[:"#{attr_prefix}#{attr}"] ||= property_hash
+            end
+          end
+
+          add_sort_params(params, model_class, sort_attrs, opts)
+        end
+
+        def add_sort_params(params, model_class, addl_sort_attrs, opts)
+          attr_prefix = opts[:attr_prefix]
+          if (sort_metadata = ModelApi::Utils.filtered_ext_attrs(model_class, :sort, opts)).present?
+            if attr_prefix.present?
+              params[:sort_by] = sort_metadata.keys.sort.map { |k| :"#{attr_prefix}#{k}" }
+            else
+              addl_sort_attrs = (sort_metadata.keys + addl_sort_attrs).compact.sort
+              params[:sort_by] = { type: :string,
+                  description: "Sortable fields: #{addl_sort_attrs.join(', ')} " \
+                    '(optionally append " asc" or " desc" on field(s) to indicate sort order)' }
+            end
+          end
+          params
+        end
+
+        def filter_description(attr_prefix, attr, property_hash, attr_metadata)
+          return attr_metadata[:filter_description] if attr_metadata[:filter_description].present?
+          desc = "Filter by #{attr_prefix}#{attr}"
+          case property_hash[:type]
+          when :string
+            case property_hash[:format]
+            when :date, :'date-time'
+              "#{desc} (supports <, <=, !=, >= > operator prefixes, comma-delimited criteria)"
+            else
+              "#{desc} (supports comma-delimited values)"
+            end
+          when :boolean
+            "#{desc} (must be true or false)"
+          when :integer, :number
+            "#{desc} (supports comma-delimited values, <, <=, !=, >= > operator prefixes)"
+          else
+            desc
+          end
+        end
+
+        def define_api_collection_response(controller_class, model_class, opts = {})
+          object_name = define_open_api_object(controller_class, model_class, opts)
+          return nil unless object_name.present?
+          wrapper_object_name = "#{object_name}:response"
+          array_metadata = { type: :array, required: true }
+          array_metadata[:'$ref'] = object_name if object_name.present?
+          controller_class.send(:open_api_object, wrapper_object_name,
+              successful: { type: :boolean, required: true,
+                  description: 'Returns true if successfully processed; otherwise false' },
+              status: { type: :string, description: 'HTTP status', required: true },
+              statusCode: { type: :integer, description: 'Numeric HTTP status code',
+                  required: true },
+              ModelApi::Utils.model_name(model_class).plural => array_metadata,
+              count: { type: :integer, description: 'Total items available', required: true },
+              page: { type: :integer, description: 'Index (1-based) of page returned',
+                  required: true },
+              pageCount: { type: :integer, description: 'Total number of pages available',
+                  required: true },
+              pageSize: { type: :integer, description: 'Maximum item count per page returned',
+                  required: true })
+          wrapper_object_name
+        end
+
+        def define_open_api_object(controller_class, define_open_api_object, opts = {})
+          define_open_api_objects(controller_class, define_open_api_object, opts).first
+        end
+
+        def define_open_api_objects(controller_class, *define_open_api_objects)
+          if define_open_api_objects.size > 1 && (opts = define_open_api_objects.last).is_a?(Hash)
+            define_open_api_objects = define_open_api_objects[0..-2]
+          else
+            opts = {}
+          end
+          object_names = []
+          define_open_api_objects.compact.uniq.each do |model_class|
+            object_names << define_open_api_object_from_model(controller_class, model_class, opts)
+          end
+          object_names.compact
+        end
+
+        def define_open_api_object_from_model(controller_class, model_class, opts = {})
+          operation = opts[:operation] || :show
+          metadata_opts = opts.merge(ModelApi::Utils.contextual_metadata_opts(opts))
+          metadata = ModelApi::Utils.filtered_attrs(model_class, operation, metadata_opts)
+          return nil unless metadata.present?
+
+          action = (opts = opts.dup).delete(:action) # Prevent inheritance
+
+          object_name = ModelApi::Utils.model_name(model_class).name
+          if (parent_object_context = opts[:object_context]).present?
+            object_name = "#{parent_object_context}|#{object_name}"
+          end
+          object_name = "#{object_name}|#{action}" if action.present?
+
+          @open_api_views_processed ||= {}
+          return object_name if @open_api_views_processed[object_name]
+          @open_api_views_processed[object_name] = model_class
+
+          class_model_base(metadata, controller_class, model_class,
+              opts.merge(object_context: object_name))
+          object_name
+        end
+
+        def class_model_base(metadata, controller_class, model_class, opts)
+          properties = {}
+          opts = opts.merge(attr_types: attr_types_from_columns(model_class))
+          metadata.each do |attr, attr_metadata|
+            properties[ModelApi::Utils.ext_attr(attr, attr_metadata)] = open_api_attr_hash(
+                controller_class, model_class, attr, attr_metadata, opts)
+          end
+          controller_class.send(:open_api_object, opts[:object_context].to_sym, properties)
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def open_api_attr_hash(controller_class, model_class, attr, attr_metadata, opts)
+          property_hash = class_model_base_property(model_class, attr, attr_metadata)
+          if (attr_type = attr_metadata[:type]).is_a?(Symbol) &&
+              ![:attribute, :association].include?(attr_type)
+            ModelApi::Utils.set_open_api_type_and_format(property_hash, attr_type)
+          else
+            attr_types = opts[:attr_types] || attr_types_from_columns(model_class)
+            if (attr_type = attr_types[attr_metadata[:key]]).present?
+              ModelApi::Utils.set_open_api_type_and_format(property_hash, attr_type)
+            elsif (assoc = model_class.reflect_on_association(attr)).present?
+              property_hash = class_model_assoc_property(property_hash, controller_class,
+                  attr_metadata, opts.merge(association: assoc))
+            end
+          end
+          property_hash[:type] ||= :string unless property_hash.include?(:'$ref')
+          property_hash
+        end
+
+        # rubocop:enable Metrics/ParameterLists
+
+        def class_model_base_property(model_class, attr, attr_metadata)
+          if (required = attr_metadata[:required]).nil?
+            required_attrs ||= required_attrs_from_validators(model_class)
+            required = required_attrs.include?(attr)
+          end
+          property_hash = { required: required ? true : false }
+          if (description = attr_metadata[:description]).present?
+            property_hash[:description] = description
+          end
+          property_hash
+        end
+
+        def class_model_assoc_property(property_hash, controller_class, attr_metadata, opts)
+          assoc = opts[:association]
+          return property_hash unless assoc.present?
+          assoc_class = assoc.class_name.constantize
+          assoc_opts = ModelApi::Utils.assoc_opts(assoc, attr_metadata, opts)
+          assoc_opts = assoc_opts.reject do |k, _v|
+            [:result, :collection_result].include?(k)
+          end
+          assoc_model = define_open_api_object(controller_class, assoc_class, assoc_opts)
+          if assoc.collection?
+            property_hash[:type] = :array
+            property_hash[:items] = { :'$ref' => assoc_model } if assoc_model.present?
+          else
+            property_hash[:'$ref'] = assoc_model if assoc_model.present?
+          end
+          property_hash
+        end
+
+        def attr_types_from_columns(model_class)
+          Hash[model_class.columns.map { |col| [col.name.to_sym, col.type] }]
+        end
+
+        def required_attrs_from_validators(model_class)
+          model_class.validators
+              .select { |v| v.is_a?(ActiveRecord::Validations::PresenceValidator) }
+              .map(&:attributes)
+              .flatten
+        end
+
+        # def add_open_api_view_params(parameters, operation, _opts = {})
+        #   parameters = {}
+        #   if operation == :index
+        #     api.param :query, :page, :integer, :optional,
+        #         'Index (1-based) of the result set page to return'
+        #     api.param :query, :page_size, :integer, :optional,
+        #         'Number of records to return per page (cannot exceed 1000)'
+        #   end
+        #   if [:index, :show].include?(operation)
+        #     api.param :query, :fields, :array, :optional, 'Field(s) to include ' \
+        #       'in the response', 'items' => { 'type' => 'string' }
+        #   end
+        # end
+        #
+        # def add_open_api_common_errors(api, operation, _opts = {})
+        #   if [:show, :update, :delete].include?(operation)
+        #     api.response :not_found, 'No entity found matching the ID provided'
+        #   end
+        #   api.response :unauthorized,
+        #       'Missing a valid access token (access_token parameter or X-Access-Token header)'
+        #   api.response :bad_request, 'One or more malformed / invalid ' \
+        #     'parameters identified for the request'
+        #   api.param :query, :access_token, :string, :optional, 'Access token ' \
+        #     'used to authenticate client'
+        #   api.param :header, :'X-Access-Token', :string, :optional,
+        #       'Access token used to authenticate client'
+        # end
+      end
+    end
+  end
+end

data/lib/model-api/renderer.rb

@@ -0,0 +1,504 @@
+require 'rexml/document'
+
+module ModelApi
+  module Renderer
+    class << self
+      def render(controller, response_obj, opts = {})
+        opts = opts.symbolize_keys
+        format = (opts[:format] ||= get_format(controller))
+        opts[:action] ||= controller.action_name.to_sym
+        if format == :xml
+          render_xml_response(response_obj, controller, opts)
+        else
+          render_json_response(response_obj, controller, opts)
+        end
+      end
+
+      private
+
+      def serializable_object(obj, opts = {})
+        obj = obj.first if obj.is_a?(ActiveRecord::Relation)
+        opts = opts.symbolize_keys
+        return nil if obj.nil?
+        operation = opts[:operation] || :show
+        metadata_opts = opts.merge(ModelApi::Utils.contextual_metadata_opts(opts))
+        metadata = ModelApi::Utils.filtered_attrs(obj, operation, metadata_opts)
+        render_values, render_assoc = attrs_by_type(obj, metadata)
+        hash = {}
+        serialize_values(hash, obj, render_values, opts)
+        serialize_associations(hash, obj, render_assoc, opts)
+        process_serializable_hash(metadata, hash, opts)
+      end
+
+      def attrs_by_type(obj, metadata)
+        render_values = []
+        render_assoc = []
+        metadata.each do |attr, attr_metadata|
+          if (value = attr_metadata[:value]).present?
+            render_values << [attr, value, attr_metadata]
+          elsif obj.respond_to?(attr.to_s)
+            render_values << [attr, obj.send(attr.to_sym), attr_metadata]
+          elsif (assoc = obj.class.reflect_on_association(attr)).present?
+            render_assoc << [assoc, attr_metadata]
+          elsif obj.is_a?(ActiveRecord::Base)
+            fail "Invalid API attribute for #{obj.class.model_name.human} instance: #{attr}"
+          else
+            fail "Invalid API attribute for #{obj.class.name} instance: #{attr}"
+          end
+        end
+        [render_values, render_assoc]
+      end
+
+      def serialize_values(hash, obj, value_procs, opts = {})
+        value_procs.each do |attr, value, attr_metadata|
+          if value.respond_to?(:call) && value.respond_to?(:parameters)
+            proc_opts = opts.merge(attr: attr, attr_metadata: attr_metadata)
+            value = value.send(*([:call, obj, proc_opts][0..value.parameters.size]))
+          end
+          hash[attr] = serialize_value(value, attr_metadata, opts)
+        end
+      end
+
+      def serialize_associations(hash, obj, associations, opts = {})
+        associations.each do |assoc, attr_metadata|
+          return nil if assoc.nil?
+          assoc_opts = ModelApi::Utils.assoc_opts(assoc, attr_metadata, opts)
+          next if assoc_opts.nil?
+          attr = assoc.name
+          assoc = assoc_opts[:association]
+          render_proc ||= ->(o) { serialize_value(o, attr_metadata, assoc_opts) }
+          if !assoc.nil? && assoc.collection?
+            value = obj.send(attr).map { |o| render_proc.call(o) }
+          else
+            value = render_proc.call(obj.send(attr))
+          end
+          hash[attr] = value
+        end
+      end
+
+      def serialize_value(value, attr_metadata, opts)
+        if (render_method = attr_metadata[:render_method]).present?
+          if render_method.respond_to?(:call)
+            value = serialize_value_proc(render_method, value)
+          else
+            value = serialize_value_obj_attr(render_method, value)
+          end
+        end
+        opts = ModelApi::Utils.contextual_metadata_opts(attr_metadata, opts)
+        opts[:operation] = :show
+        if value.respond_to?(:map)
+          return value.map do |elem|
+            elem.is_a?(ActiveRecord::Base) ? serializable_object(elem, opts) : elem
+          end
+        elsif value.is_a?(ActiveRecord::Base)
+          return serializable_object(value, opts)
+        end
+        value
+      end
+
+      def serialize_value_proc(render_method, value)
+        if render_method.parameters.count > 1
+          render_method.call(value, opts)
+        else
+          render_method.call(value)
+        end
+      end
+
+      def serialize_value_obj_attr(render_method, value)
+        render_method = render_method.to_s.to_sym
+        if value.is_a?(ActiveRecord::Associations::CollectionProxy) || value.is_a?(Array)
+          (value.map do |obj|
+            obj.respond_to?(render_method) ? obj.send(render_method) : nil
+          end).compact
+        elsif value.respond_to?(render_method)
+          value.send(render_method)
+        end
+      end
+
+      def process_serializable_hash(api_attrs_metadata, hash, opts)
+        updated_hash_array = (hash.map do |key, value|
+          attr_metadata = api_attrs_metadata[key.to_sym] || {}
+          value = ModelApi::Utils.format_value(value, attr_metadata, opts)
+          next nil if value.nil? && attr_metadata[:hide_when_nil]
+          [ModelApi::Utils.ext_attr(key, attr_metadata).to_sym, value]
+        end).compact
+        api_attrs = api_attrs_metadata.map { |k, m| ModelApi::Utils.ext_attr(k, m).to_sym }
+        updated_hash_array.sort_by! do |key, _value|
+          api_attrs.find_index(key.to_s.to_sym) || api_attrs.size
+        end
+        Hash[updated_hash_array]
+      end
+
+      def get_format(controller)
+        format = controller.request.format.symbol rescue :json
+        format == :xml ? :xml : :json
+      end
+
+      def get_object_root_elem(obj, opts)
+        if (root_elem = opts[:root]).present?
+          return root_elem
+        end
+        if obj.respond_to?(:klass)
+          item_class = obj.klass
+        elsif obj.nil?
+          item_class = Object
+        else
+          item_class = obj.class
+        end
+        return 'response' if item_class == Hash
+        ModelApi::Utils.model_name(item_class).singular
+      end
+
+      def get_collection_root_elem(collection, opts)
+        if (root_elem = opts[:root]).present?
+          return root_elem
+        end
+        if collection.respond_to?(:klass)
+          item_class = collection.klass
+        elsif collection.respond_to?(:first) && (first_obj = collection.first).present?
+          item_class = first_obj.class
+        else
+          item_class = Object
+        end
+        ModelApi::Utils.model_name(item_class).plural
+      end
+
+      def hateoas_link_xml(links, _opts = {})
+        '<_links>' +
+            links.map do |link|
+              '<link' + link.map { |k, v| " #{k}=\"#{CGI.escapeHTML(v)}\"" }.join + ' />'
+            end.join +
+            '</_links>'
+      end
+
+      def hateoas_pagination_values_json(count, page, page_count, page_size)
+        json = []
+        if count.present?
+          json << ",\"#{ModelApi::Utils.ext_attr(:count)}\":#{[count.to_i, 0].max}"
+        end
+        json << ",\"#{ModelApi::Utils.ext_attr(:page)}\":#{[page.to_i, 0].max}" if page.present?
+        if page_count.present?
+          json << ",\"#{ModelApi::Utils.ext_attr(:page_count)}\":#{[page_count.to_i, 0].max}"
+        end
+        if page_size.present?
+          json << ",\"#{ModelApi::Utils.ext_attr(:page_size)}\":#{[page_size.to_i, 0].max}"
+        end
+        json.join
+      end
+
+      def hateoas_pagination_values_xml(count, page, page_count, page_size)
+        xml = []
+        count_attr = ModelApi::Utils.ext_attr(:count)
+        page_attr = ModelApi::Utils.ext_attr(:page)
+        page_count_attr = ModelApi::Utils.ext_attr(:page_count)
+        page_size_attr = ModelApi::Utils.ext_attr(:page_size)
+        xml << "<#{count_attr}>#{[count.to_i, 0].max}</#{count_attr}>" if count.present?
+        xml << "<#{page_attr}>#{[page.to_i, 0].max}</#{page_attr}>" if page.present?
+        if page_count.present?
+          xml << "<#{page_count_attr}>#{[page_count.to_i, 0].max}</#{page_count_attr}>"
+        end
+        if page_size.present?
+          xml << "<#{page_size_attr}>#{[page_size.to_i, 0].max}</#{page_size_attr}>"
+        end
+        xml.join
+      end
+
+      def object_hateoas_links(object_links, obj, controller, opts = {})
+        return {} if obj.blank?
+        custom_links = ModelApi::Utils.filtered_links(obj, opts[:operation], opts)
+        links = (object_links || {}).merge(custom_links).map do |rel, route|
+          next { rel: rel.to_s, href: route.to_s } if route.is_a?(URI)
+          if route.is_a?(Hash)
+            link_opts = opts.merge(route)
+            route = link_opts.delete(:route)
+            next nil if route.blank?
+          else
+            link_opts = opts
+          end
+          next { rel: rel.to_s, href: route.to_s } if route.is_a?(URI)
+          route_args = build_object_hateoas_route_args(obj, controller, route, link_opts)
+          if route_args[0].respond_to?(:url_for)
+            next { rel: rel.to_s, href: route_args[0].url_for(*route_args.slice(1..-1)) }
+          elsif !controller.respond_to?(route_args[0].to_s.to_sym)
+            route_args[0] = :"#{route_args[0]}_url"
+            next nil unless controller.respond_to?(route_args[0])
+          end
+          begin
+            param_count = controller.method(route_args[0]).parameters.size
+            { rel: rel.to_s, href: controller.send(*(route_args[0..param_count])) }
+          rescue Exception => e
+            Rails.logger.warn "Error encountered generating \"#{rel}\" " \
+                "link (\"#{e.message}\") for #{obj.class.name}: " \
+                "#{(obj.respond_to?(:guid) ? obj.guid : obj.id)}"
+            nil
+          end
+        end
+        links.compact
+      end
+
+      def build_object_hateoas_route_args(obj, controller, route, opts = {})
+        id_attr = opts[:id_attribute] || :id
+        link_opts = (opts[:object_link_options] || {}).dup
+        format = controller.request.format.symbol rescue nil
+        link_opts[:format] ||= format if format.present?
+        if route.is_a?(Array)
+          if route.size > 1 && (route_opts = route.last).is_a?(Hash)
+            route.first(route.size - 1).append(link_opts.merge(route_opts))
+          else
+            route + [object.send(id_attr), link_opts]
+          end
+        else
+          id = obj.is_a?(Hash) ? obj[id_attr] : obj.send(id_attr)
+          path_params = Rails.application.routes.routes.named_routes[route.to_s].parts rescue []
+          path_params.each do |param|
+            param = param.to_sym
+            next if link_opts.include?(param)
+            value = controller.params[param]
+            link_opts[param] = value if value.present?
+          end
+          [route, { (opts[:id_param] || :id) => id }.merge(link_opts)]
+        end
+      end
+
+      def hateoas_links(links, common_link_opts, controller, opts = {})
+        links = (links || {}).map do |rel, route|
+          if route.is_a?(Hash)
+            link_opts = route.merge(common_link_opts)
+            route = link_opts.delete(:route)
+          else
+            link_opts = common_link_opts
+          end
+          next { rel: rel.to_s, href: route.to_s } if route.is_a?(URI)
+          route_args = build_hateoas_route_args(controller, route, link_opts, opts)
+          if route_args[0].respond_to?(:url_for)
+            next { rel: rel.to_s, href: route_args[0].url_for(*route_args.slice(1..-1)) }
+          elsif !controller.respond_to?(route_args[0])
+            route_args[0] = :"#{route_args[0]}_url"
+            next nil unless controller.respond_to?(route_args[0])
+          end
+          begin
+            { rel: rel.to_s, href: controller.send(*route_args) }
+          rescue Exception => e
+            Rails.logger.warn "Error encountered generating \"#{rel}\" link " \
+                "(\"#{e.message}\") for collection."
+            nil
+          end
+        end
+        links.compact
+      end
+
+      def build_hateoas_route_args(controller, route, link_opts, _opts = {})
+        link_opts ||= {}
+        format = controller.request.format.symbol rescue nil
+        link_opts[:format] ||= format if format.present?
+        if route.is_a?(Array)
+          if route.size > 1 && (route_opts = route.last).is_a?(Hash)
+            route.first(route.size - 1).append(link_opts.merge(route_opts))
+          else
+            route.append(link_opts)
+          end
+        else
+          [route, link_opts]
+        end
+      end
+
+      def hateoas_object(obj, controller, format, opts = {})
+        object_links = object_hateoas_links(opts[:object_links], obj, controller, opts)
+        hash = serializable_object(obj, opts)
+        if format == :xml
+          root_tag = ModelApi::Utils.ext_attr(opts[:root] || get_object_root_elem(obj, opts) || :obj)
+          end_tag = "</#{root_tag}>"
+          if object_links.present?
+            pretty_xml(hash
+                .to_xml(opts.merge(root: root_tag, skip_instruct: true))
+                .sub(Regexp.new('(' + Regexp.escape(end_tag) + ')\\w*\\Z'),
+                    hateoas_link_xml(object_links, opts) + end_tag))
+          else
+            pretty_xml(hash.to_xml(opts.merge(root: root_tag, skip_instruct: true)))
+          end
+        else
+          hash[:_links] = object_links
+          hash.to_json(opts)
+        end
+      end
+
+      def hateoas_collection(collection, controller, format, opts = {})
+        opts = (opts || {}).symbolize_keys
+        count = opts[:count]
+        page = opts[:page]
+        page_count = opts[:page_count]
+        page_size = opts[:page_size]
+        root_tag = ModelApi::Utils.ext_attr(opts[:root] || get_collection_root_elem(collection, opts) ||
+            :objects)
+        if format == :xml
+          children_tag = opts.delete(:children) || root_tag.to_s.singularize
+          response_xml = []
+          response_xml << "<#{root_tag}>"
+          collection.each do |obj|
+            response_xml << hateoas_object(obj, controller, format, opts.merge(root: children_tag))
+          end
+          response_xml << "</#{root_tag}>"
+          response_xml << hateoas_pagination_values_xml(count, page, page_count, page_size)
+          pretty_xml(response_xml.join)
+        else
+          "\"#{root_tag}\":[" + collection.map do |obj|
+            hateoas_object(obj, controller, format, opts)
+          end.join(',') + ']' +
+              hateoas_pagination_values_json(count, page, page_count, page_size)
+        end
+      end
+
+      def render_xml_response(response_obj, controller, opts = {})
+        http_status, http_status_code = http_status_and_status_code(controller, opts)
+        successful = ModelApi::Utils.response_successful?(http_status_code)
+        response_xml = render_xml_response_heading(http_status, opts)
+        render_xml_response_body(response_xml, response_obj, controller, opts)
+        response_xml << "</#{ModelApi::Utils.ext_attr(:response)}>"
+        return pretty_xml(response_xml.join) if opts[:generate_body_only]
+        set_location_header(response_obj, controller, successful, opts)
+        controller.render status: http_status, xml: pretty_xml(response_xml.join)
+        successful
+      end
+
+      def render_xml_response_heading(status, opts = {})
+        http_status_code = ModelApi::Utils.http_status_code(status)
+        successful = ModelApi::Utils.response_successful?(http_status_code)
+        successful_tag = ModelApi::Utils.ext_attr(:successful)
+        status_tag = ModelApi::Utils.ext_attr(:status)
+        status_code_tag = ModelApi::Utils.ext_attr(:status_code)
+        response_xml = []
+        response_xml << "<#{ModelApi::Utils.ext_attr(:response)}>"
+        response_xml << "<#{successful_tag}>#{successful ? 'true' : 'false'}</#{successful_tag}>"
+        response_xml << "<#{status_tag}>#{status}</#{status_tag}>"
+        response_xml << "<#{status_code_tag}>#{http_status_code}</#{status_code_tag}>"
+        if opts[:messages].present?
+          response_xml << xml_collection_elem_tags_with_attrs(
+              ModelApi::Utils.ext_attr(successful ? :messages : :errors), opts[:messages])
+        end
+        response_xml
+      end
+
+      def render_xml_response_body(response_xml, response_obj, controller,
+          opts = {})
+        collection = false
+        if response_obj.is_a?(ActiveRecord::Base)
+          response_xml << hateoas_object(response_obj, controller, opts[:format] || :xml, opts)
+        elsif !response_obj.is_a?(Hash) && response_obj.respond_to?(:map)
+          response_xml << hateoas_collection(response_obj, controller, opts[:format] || :xml, opts)
+          collection = true
+        elsif response_obj.present?
+          root = ModelApi::Utils.ext_attr(opts[:root] || get_object_root_elem(response_obj, opts) ||
+              :response)
+          response_xml << response_obj.to_xml(opts.merge(skip_instruct: true, root: root)).rstrip
+        end
+        if opts[:ignored_fields].present?
+          response_xml << xml_collection_elem_tags_with_attrs(
+              ModelApi::Utils.ext_attr(:ignored_fields), opts[:ignored_fields])
+        end
+        if collection
+          if (links = hateoas_links(opts[:collection_links],
+              opts[:collection_link_options], controller, opts)).present?
+            response_xml << hateoas_link_xml(links, opts)
+          end
+        elsif (links = hateoas_links(opts[:links], opts[:link_opts], controller, opts)).present?
+          response_xml << hateoas_link_xml(links, opts)
+        end
+        response_xml
+      end
+
+      def http_status_and_status_code(controller, opts = {})
+        if opts[:status].present?
+          return [opts[:status].to_sym, ModelApi::Utils.http_status_code(opts[:status].to_sym)]
+        elsif opts[:status_code].present?
+          return [ModelApi::Utils.http_status(opts[:status_code].to_i), opts[:status_code].to_i]
+        elsif controller.response.status.present? && controller.response.status > 0
+          return [ModelApi::Utils.http_status(controller.response.status), controller.response.status]
+        else
+          return [:ok, ModelApi::Utils.http_status_code(:ok)]
+        end
+      end
+
+      def render_json_response(response_obj, controller, opts = {})
+        http_status, http_status_code = http_status_and_status_code(controller, opts)
+        successful = ModelApi::Utils.response_successful?(http_status_code)
+        response_json = "\"#{ModelApi::Utils.ext_attr(:successful)}\":#{successful ? 'true' : 'false'},"
+        response_json += "\"#{ModelApi::Utils.ext_attr(:status)}\":\"#{http_status}\","
+        response_json += "\"#{ModelApi::Utils.ext_attr(:status_code)}\":#{http_status_code}"
+        if opts[:messages].present?
+          response_json += ",\"#{ModelApi::Utils.ext_attr(successful ? :messages : :errors)}\":" +
+              opts[:messages].to_json(opts)
+        end
+        response_json += build_response_obj_json(response_obj, controller, opts)
+        if opts[:ignored_fields].present?
+          response_json += ",\"#{ModelApi::Utils.ext_attr(:ignored_fields)}\":" +
+              opts[:ignored_fields].to_json(opts)
+        end
+        return "{#{response_json}}" if opts[:generate_body_only]
+        set_location_header(response_obj, controller, successful, opts)
+        controller.render status: http_status, json: "{#{response_json}}"
+        successful
+      end
+
+      def build_response_obj_json(response_obj, controller, opts = {})
+        if !response_obj.nil?
+          if response_obj.is_a?(ActiveRecord::Base)
+            root_elem_json = ModelApi::Utils.ext_attr(get_object_root_elem(response_obj, opts)).to_json
+            response_json = ",#{root_elem_json}:" +
+                hateoas_object(response_obj, controller, opts[:format] || :json, opts)
+            links = hateoas_links(opts[:links], opts[:link_opts], controller, opts)
+          elsif !response_obj.is_a?(Hash) && response_obj.respond_to?(:map)
+            response_json = ',' + hateoas_collection(response_obj, controller,
+                opts[:format] || :json, opts)
+            links = hateoas_links(opts[:collection_links],
+                opts[:collection_link_options], controller, opts)
+          else
+            root_elem_json = ModelApi::Utils.ext_attr(get_object_root_elem(response_obj, opts)).to_json
+            response_json = ",#{root_elem_json}:" + response_obj.to_json(opts)
+            links = hateoas_links(opts[:links], opts[:link_opts], controller, opts)
+          end
+          if links.present?
+            response_json += ",\"_links\":" + links.to_json(opts)
+          end
+          response_json
+        else
+          ''
+        end
+      end
+
+      def xml_elem_tags_with_attrs(element, hash)
+        tags = hash.map do |attr, value|
+          " #{attr}=\"#{CGI.escapeHTML(value.to_s)}\""
+        end
+        "<#{element}#{tags.join} />"
+      end
+
+      def xml_collection_elem_tags_with_attrs(element, array, opts = {})
+        child_element = opts[:children] || element.to_s.singularize
+        tags = array.map do |hash|
+          xml_elem_tags_with_attrs(child_element, hash)
+        end
+        "<#{element}>#{tags.join}</#{element}>"
+      end
+
+      def pretty_xml(xml, _indent = 2)
+        xml_doc = REXML::Document.new(xml) rescue nil
+        return xml unless xml_doc.present?
+        formatter = REXML::Formatters::Pretty.new
+        formatter.compact = true
+        out = ''
+        formatter.write(xml_doc, out)
+        out || xml
+      end
+
+      def set_location_header(response_obj, controller, successful, opts = {})
+        return unless successful && opts[:location_header] &&
+            response_obj.is_a?(ActiveRecord::Base)
+        links = opts[:object_links]
+        return unless links.is_a?(Hash) && links.include?(:self)
+        link = object_hateoas_links({ self: links[:self] }, response_obj, controller,
+            opts.merge(exclude_api_links: true)).find { |l| l[:rel].to_s == 'self' }
+        controller.response.header['Location'] = link[:href] if link.include?(:href)
+      end
+    end
+  end
+end