active_model_serializers_custom 0.10.90

data/lib/active_model_serializers/serializable_resource.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module ActiveModelSerializers
+  class SerializableResource
+    ADAPTER_OPTION_KEYS = Set.new([:include, :fields, :adapter, :meta, :meta_key, :links, :serialization_context, :key_transform])
+    include ActiveModelSerializers::Logging
+
+    delegate :serializable_hash, :as_json, :to_json, to: :adapter
+    notify :serializable_hash, :render
+    notify :as_json, :render
+    notify :to_json, :render
+
+    # Primary interface to composing a resource with a serializer and adapter.
+    # @return the serializable_resource, ready for #as_json/#to_json/#serializable_hash.
+    def initialize(resource, options = {})
+      @resource = resource
+      @adapter_opts = options.select { |k, _| ADAPTER_OPTION_KEYS.include? k }
+      @serializer_opts = options.reject { |k, _| ADAPTER_OPTION_KEYS.include? k }
+    end
+
+    def serialization_scope=(scope)
+      serializer_opts[:scope] = scope
+    end
+
+    def serialization_scope
+      serializer_opts[:scope]
+    end
+
+    def serialization_scope_name=(scope_name)
+      serializer_opts[:scope_name] = scope_name
+    end
+
+    # NOTE: if no adapter is available, returns the resource itself. (i.e. adapter is a no-op)
+    def adapter
+      @adapter ||= find_adapter
+    end
+    alias adapter_instance adapter
+
+    def find_adapter
+      return resource unless serializer?
+      adapter = catch :no_serializer do
+        ActiveModelSerializers::Adapter.create(serializer_instance, adapter_opts)
+      end
+      adapter || resource
+    end
+
+    def serializer_instance
+      @serializer_instance ||= serializer.new(resource, serializer_opts)
+    end
+
+    # Get serializer either explicitly :serializer or implicitly from resource
+    # Remove :serializer key from serializer_opts
+    # Remove :each_serializer if present and set as :serializer key
+    def serializer
+      @serializer ||=
+        begin
+          @serializer = serializer_opts.delete(:serializer)
+          @serializer ||= ActiveModel::Serializer.serializer_for(resource, serializer_opts)
+
+          if serializer_opts.key?(:each_serializer)
+            serializer_opts[:serializer] = serializer_opts.delete(:each_serializer)
+          end
+          @serializer
+        end
+    end
+    alias serializer_class serializer
+
+    # True when no explicit adapter given, or explicit appear is truthy (non-nil)
+    # False when explicit adapter is falsy (nil or false)
+    def use_adapter?
+      !(adapter_opts.key?(:adapter) && !adapter_opts[:adapter])
+    end
+
+    def serializer?
+      use_adapter? && !serializer.nil?
+    end
+
+    protected
+
+    attr_reader :resource, :adapter_opts, :serializer_opts
+  end
+end

data/lib/active_model_serializers/serialization_context.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/extract_options'
+module ActiveModelSerializers
+  class SerializationContext
+    class << self
+      attr_writer :url_helpers, :default_url_options
+      def url_helpers
+        @url_helpers ||= Module.new
+      end
+
+      def default_url_options
+        @default_url_options ||= {}
+      end
+    end
+    module UrlHelpers
+      def self.included(base)
+        base.send(:include, SerializationContext.url_helpers)
+      end
+
+      def default_url_options
+        SerializationContext.default_url_options
+      end
+    end
+
+    attr_reader :request_url, :query_parameters, :key_transform
+
+    def initialize(*args)
+      options = args.extract_options!
+      if args.size == 1
+        request = args.pop
+        options[:request_url] = request.original_url[/\A[^?]+/]
+        options[:query_parameters] = request.query_parameters
+      end
+      @request_url = options.delete(:request_url)
+      @query_parameters = options.delete(:query_parameters)
+      @url_helpers = options.delete(:url_helpers) || self.class.url_helpers
+      @default_url_options = options.delete(:default_url_options) || self.class.default_url_options
+    end
+  end
+end

data/lib/active_model_serializers/test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module Test
+    extend ActiveSupport::Autoload
+    autoload :Serializer
+    autoload :Schema
+  end
+end

data/lib/active_model_serializers/test/schema.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module Test
+    module Schema
+      # A Minitest Assertion that test the response is valid against a schema.
+      # @param schema_path [String] a custom schema path
+      # @param message [String] a custom error message
+      # @return [Boolean] true when the response is valid
+      # @return [Minitest::Assertion] when the response is invalid
+      # @example
+      #   get :index
+      #   assert_response_schema
+      def assert_response_schema(schema_path = nil, message = nil)
+        matcher = AssertResponseSchema.new(schema_path, request, response, message)
+        assert(matcher.call, matcher.message)
+      end
+
+      def assert_request_schema(schema_path = nil, message = nil)
+        matcher = AssertRequestSchema.new(schema_path, request, response, message)
+        assert(matcher.call, matcher.message)
+      end
+
+      # May be renamed
+      def assert_request_response_schema(schema_path = nil, message = nil)
+        assert_request_schema(schema_path, message)
+        assert_response_schema(schema_path, message)
+      end
+
+      def assert_schema(payload, schema_path = nil, message = nil)
+        matcher = AssertSchema.new(schema_path, request, response, message, payload)
+        assert(matcher.call, matcher.message)
+      end
+
+      MissingSchema = Class.new(Minitest::Assertion)
+      InvalidSchemaError = Class.new(Minitest::Assertion)
+
+      class AssertSchema
+        attr_reader :schema_path, :request, :response, :message, :payload
+
+        # Interface may change.
+        def initialize(schema_path, request, response, message, payload = nil)
+          require_json_schema!
+          @request = request
+          @response = response
+          @payload = payload
+          @schema_path = schema_path || schema_path_default
+          @message = message
+          @document_store = JsonSchema::DocumentStore.new
+          add_schema_to_document_store
+        end
+
+        def call
+          json_schema.expand_references!(store: document_store)
+          status, errors = json_schema.validate(response_body)
+          @message = [message, errors.map(&:to_s).to_sentence].compact.join(': ')
+          status
+        end
+
+        protected
+
+        attr_reader :document_store
+
+        def controller_path
+          request.filtered_parameters.with_indifferent_access[:controller]
+        end
+
+        def action
+          request.filtered_parameters.with_indifferent_access[:action]
+        end
+
+        def schema_directory
+          ActiveModelSerializers.config.schema_path
+        end
+
+        def schema_full_path
+          "#{schema_directory}/#{schema_path}"
+        end
+
+        def schema_path_default
+          "#{controller_path}/#{action}.json"
+        end
+
+        def schema_data
+          load_json_file(schema_full_path)
+        end
+
+        def response_body
+          load_json(response.body)
+        end
+
+        def request_params
+          request.env['action_dispatch.request.request_parameters']
+        end
+
+        def json_schema
+          @json_schema ||= JsonSchema.parse!(schema_data)
+        end
+
+        def add_schema_to_document_store
+          Dir.glob("#{schema_directory}/**/*.json").each do |path|
+            schema_data = load_json_file(path)
+            extra_schema = JsonSchema.parse!(schema_data)
+            document_store.add_schema(extra_schema)
+          end
+        end
+
+        def load_json(json)
+          JSON.parse(json)
+        rescue JSON::ParserError => ex
+          raise InvalidSchemaError, ex.message
+        end
+
+        def load_json_file(path)
+          load_json(File.read(path))
+        rescue Errno::ENOENT
+          raise MissingSchema, "No Schema file at #{schema_full_path}"
+        end
+
+        def require_json_schema!
+          require 'json_schema'
+        rescue LoadError
+          raise LoadError, "You don't have json_schema installed in your application. Please add it to your Gemfile and run bundle install"
+        end
+      end
+      class AssertResponseSchema < AssertSchema
+        def initialize(*)
+          super
+          @payload = response_body
+        end
+      end
+      class AssertRequestSchema < AssertSchema
+        def initialize(*)
+          super
+          @payload = request_params
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/test/serializer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'set'
+module ActiveModelSerializers
+  module Test
+    module Serializer
+      extend ActiveSupport::Concern
+
+      included do
+        setup :setup_serialization_subscriptions
+        teardown :teardown_serialization_subscriptions
+      end
+
+      # Asserts that the request was rendered with the appropriate serializers.
+      #
+      #  # assert that the "PostSerializer" serializer was rendered
+      #  assert_serializer "PostSerializer"
+      #
+      #  # return a custom error message
+      #  assert_serializer "PostSerializer", "PostSerializer not rendered"
+      #
+      #  # assert that the instance of PostSerializer was rendered
+      #  assert_serializer PostSerializer
+      #
+      #  # assert that the "PostSerializer" serializer was rendered
+      #  assert_serializer :post_serializer
+      #
+      #  # assert that the rendered serializer starts with "Post"
+      #  assert_serializer %r{\APost.+\Z}
+      #
+      #  # assert that no serializer was rendered
+      #  assert_serializer nil
+      #
+      def assert_serializer(expectation, message = nil)
+        @assert_serializer.expectation = expectation
+        @assert_serializer.message = message
+        @assert_serializer.response = response
+        assert(@assert_serializer.matches?, @assert_serializer.message)
+      end
+
+      class AssertSerializer
+        attr_reader :serializers, :message
+        attr_accessor :response, :expectation
+
+        def initialize
+          @serializers = Set.new
+          @_subscribers = []
+        end
+
+        def message=(message)
+          @message = message || "expecting <#{expectation.inspect}> but rendering with <#{serializers.to_a}>"
+        end
+
+        def matches?
+          # Force body to be read in case the template is being streamed.
+          response.body
+
+          case expectation
+          when a_serializer? then matches_class?
+          when Symbol        then matches_symbol?
+          when String        then matches_string?
+          when Regexp        then matches_regexp?
+          when NilClass      then matches_nil?
+          else fail ArgumentError, 'assert_serializer only accepts a String, Symbol, Regexp, ActiveModel::Serializer, or nil'
+          end
+        end
+
+        def subscribe
+          @_subscribers << ActiveSupport::Notifications.subscribe(event_name) do |_name, _start, _finish, _id, payload|
+            serializer = payload[:serializer].name
+            serializers << serializer
+          end
+        end
+
+        def unsubscribe
+          @_subscribers.each do |subscriber|
+            ActiveSupport::Notifications.unsubscribe(subscriber)
+          end
+        end
+
+        private
+
+        def matches_class?
+          serializers.include?(expectation.name)
+        end
+
+        def matches_symbol?
+          camelize_expectation = expectation.to_s.camelize
+          serializers.include?(camelize_expectation)
+        end
+
+        def matches_string?
+          !expectation.empty? && serializers.include?(expectation)
+        end
+
+        def matches_regexp?
+          serializers.any? do |serializer|
+            serializer.match(expectation)
+          end
+        end
+
+        def matches_nil?
+          serializers.empty?
+        end
+
+        def a_serializer?
+          ->(exp) { exp.is_a?(Class) && exp < ActiveModel::Serializer }
+        end
+
+        def event_name
+          ::ActiveModelSerializers::Logging::RENDER_EVENT
+        end
+      end
+
+      private
+
+      def setup_serialization_subscriptions
+        @assert_serializer = AssertSerializer.new
+        @assert_serializer.subscribe
+      end
+
+      def teardown_serialization_subscriptions
+        @assert_serializer.unsubscribe
+      end
+    end
+  end
+end

data/lib/generators/rails/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Generates a serializer for the given resource.
+
+Example:
+    `rails generate serializer Account name created_at`
+

data/lib/generators/rails/resource_override.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/rails/resource/resource_generator'
+
+module Rails
+  module Generators
+    class ResourceGenerator
+      hook_for :serializer, default: true, type: :boolean
+    end
+  end
+end

data/lib/generators/rails/serializer_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    class SerializerGenerator < NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+      check_class_collision suffix: 'Serializer'
+
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+      class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
+
+      def create_serializer_file
+        template 'serializer.rb.erb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+      end
+
+      private
+
+      def attributes_names
+        [:id] + attributes.reject(&:reference?).map! { |a| a.name.to_sym }
+      end
+
+      def association_names
+        attributes.select(&:reference?).map! { |a| a.name.to_sym }
+      end
+
+      def parent_class_name
+        if options[:parent]
+          options[:parent]
+        elsif 'ApplicationSerializer'.safe_constantize
+          'ApplicationSerializer'
+        else
+          'ActiveModel::Serializer'
+        end
+      end
+    end
+  end
+end