active_model_serializers 0.9.12 → 0.10.15

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/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.rb

@@ -1,32 +1,63 @@
 # frozen_string_literal: true
 
 require 'active_model'
-require 'active_model/serializer'
-require 'active_model/serializer_support'
-require 'active_model/serializer/version'
-require 'active_model/serializer/railtie' if defined?(Rails)
-
-begin
-  require 'action_controller'
-  require 'action_controller/serialization'
-
-  ActiveSupport.on_load(:action_controller) do
-    if ::ActionController::Serialization.enabled
-      ActionController::Base.send(:include, ::ActionController::Serialization)
-
-      # action_controller_test_case load hook was added in Rails 5.1
-      # https://github.com/rails/rails/commit/0510208dd1ff23baa619884c0abcae4d141fae53
-      if ActiveSupport::VERSION::STRING < '5.1'
-        require 'action_controller/serialization_test_case'
-        ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)
-      else
-        ActiveSupport.on_load(:action_controller_test_case) do
-          require 'action_controller/serialization_test_case'
-          ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)
-        end
-      end
-    end
+require 'active_support'
+require 'active_support/core_ext/object/with_options'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/json'
+module ActiveModelSerializers
+  extend ActiveSupport::Autoload
+  eager_autoload do
+    autoload :Model
+    autoload :Callbacks
+    autoload :SerializableResource
+    autoload :SerializationContext
+    autoload :Logging
+    autoload :Test
+    autoload :Adapter
+    autoload :JsonPointer
+    autoload :Deprecate
+    autoload :LookupChain
+    autoload :Deserialization
   end
-rescue LoadError
-  # rails not installed, continuing
+
+  class << self; attr_accessor :logger; end
+  self.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+  def self.config
+    ActiveModel::Serializer.config
+  end
+
+  # The file name and line number of the caller of the caller of this method.
+  def self.location_of_caller
+    caller[1] =~ /(.*?):(\d+).*?$/i
+    file = Regexp.last_match(1)
+    lineno = Regexp.last_match(2).to_i
+
+    [file, lineno]
+  end
+
+  # Memoized default include directive
+  # @return [JSONAPI::IncludeDirective]
+  def self.default_include_directive
+    @default_include_directive ||= JSONAPI::IncludeDirective.new(config.default_includes, allow_wildcard: true)
+  end
+
+  def self.silence_warnings
+    original_verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbose
+  end
+
+  def self.eager_load!
+    super
+    ActiveModel::Serializer.eager_load!
+  end
+
+  require 'active_model/serializer/version'
+  require 'active_model/serializer'
+  require 'active_model/serializable_resource'
+  require 'active_model_serializers/railtie' if defined?(::Rails::Railtie)
 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/{active_model/serializer/generators → generators/rails}/resource_override.rb

@@ -6,10 +6,7 @@ require 'rails/generators/rails/resource/resource_generator'
 module Rails
   module Generators
     class ResourceGenerator
-      def add_serializer
-        invoke 'serializer'
-      end
+      hook_for :serializer, default: true, type: :boolean
     end
   end
 end
-

data/lib/{active_model/serializer/generators/serializer → generators/rails}/serializer_generator.rb

@@ -11,24 +11,23 @@ module Rails
       class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
 
       def create_serializer_file
-        template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+        template 'serializer.rb.erb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
       end
 
       private
 
       def attributes_names
-        [:id] + attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }
+        [:id] + attributes.reject(&:reference?).map! { |a| a.name.to_sym }
       end
 
       def association_names
-        attributes.select { |attr| attr.reference? }.map { |a| a.name.to_sym }
+        attributes.select(&:reference?).map! { |a| a.name.to_sym }
       end
 
       def parent_class_name
         if options[:parent]
           options[:parent]
-        elsif (ns = Rails::Generators.namespace) && ns.const_defined?(:ApplicationSerializer) ||
-               (Object.const_get(:ApplicationSerializer) rescue nil)
+        elsif 'ApplicationSerializer'.safe_constantize
           'ApplicationSerializer'
         else
           'ActiveModel::Serializer'

data/lib/grape/active_model_serializers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# To add Grape support, require 'grape/active_model_serializers' in the base of your Grape endpoints
+# Then add 'include Grape::ActiveModelSerializers' to enable the formatter and helpers
+require 'active_model_serializers'
+require 'grape/formatters/active_model_serializers'
+require 'grape/helpers/active_model_serializers'
+
+module Grape
+  module ActiveModelSerializers
+    extend ActiveSupport::Concern
+
+    included do
+      formatter :json, Grape::Formatters::ActiveModelSerializers
+      helpers Grape::Helpers::ActiveModelSerializers
+    end
+  end
+end

data/lib/grape/formatters/active_model_serializers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# A Grape response formatter that can be used as 'formatter :json, Grape::Formatters::ActiveModelSerializers'
+#
+# Serializer options can be passed as a hash from your Grape endpoint using env[:active_model_serializer_options],
+# or better yet user the render helper in Grape::Helpers::ActiveModelSerializers
+
+require 'active_model_serializers/serialization_context'
+
+module Grape
+  module Formatters
+    module ActiveModelSerializers
+      def self.call(resource, env)
+        serializer_options = build_serializer_options(env)
+        ::ActiveModelSerializers::SerializableResource.new(resource, serializer_options).to_json
+      end
+
+      def self.build_serializer_options(env)
+        ams_options = env[:active_model_serializer_options] || {}
+
+        # Add serialization context
+        ams_options.fetch(:serialization_context) do
+          request = env['grape.request']
+          ams_options[:serialization_context] = ::ActiveModelSerializers::SerializationContext.new(
+            request_url: request.url[/\A[^?]+/],
+            query_parameters: request.params
+          )
+        end
+
+        ams_options
+      end
+    end
+  end
+end

data/lib/grape/helpers/active_model_serializers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Helpers can be included in your Grape endpoint as: helpers Grape::Helpers::ActiveModelSerializers
+
+module Grape
+  module Helpers
+    module ActiveModelSerializers
+      # A convenience method for passing ActiveModelSerializers serializer options
+      #
+      # Example: To include relationships in the response: render(post, include: ['comments'])
+      #
+      # Example: To include pagination meta data: render(posts, meta: { page: posts.page, total_pages: posts.total_pages })
+      def render(resource, active_model_serializer_options = {})
+        env[:active_model_serializer_options] = active_model_serializer_options
+        resource
+      end
+    end
+  end
+end

data/lib/tasks/rubocop.rake

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+begin
+  require 'rubocop'
+  require 'rubocop/rake_task'
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+else
+  require 'rbconfig'
+  # https://github.com/bundler/bundler/blob/1b3eb2465a/lib/bundler/constants.rb#L2
+  windows_platforms = /(msdos|mswin|djgpp|mingw)/
+  if RbConfig::CONFIG['host_os'] =~ windows_platforms
+    desc 'No-op rubocop on Windows-- unsupported platform'
+    task :rubocop do
+      puts 'Skipping rubocop on Windows'
+    end
+  elsif defined?(::Rubinius)
+    desc 'No-op rubocop to avoid rbx segfault'
+    task :rubocop do
+      puts 'Skipping rubocop on rbx due to segfault'
+      puts 'https://github.com/rubinius/rubinius/issues/3499'
+    end
+  else
+    Rake::Task[:rubocop].clear if Rake::Task.task_defined?(:rubocop)
+    patterns = [
+      'Gemfile',
+      'Rakefile',
+      'lib/**/*.{rb,rake}',
+      'config/**/*.rb',
+      'app/**/*.rb',
+      'test/**/*.rb'
+    ]
+    desc 'Execute rubocop'
+    RuboCop::RakeTask.new(:rubocop) do |task|
+      task.options = [
+        ('--rails' if Gem::Version.new(RuboCop::Version.version) < Gem::Version.new('0.72.0')),
+        '--display-cop-names',
+        '--display-style-guide',
+        ['--config', RUBY_VERSION < '3.0' ? '.rubocop_v0.yml' : '.rubocop_v1.yml']
+      ].compact
+      task.formatters = ['progress']
+      task.patterns = patterns
+      task.fail_on_error = true
+    end
+
+    namespace :rubocop do
+      desc 'Auto-gen rubocop config'
+      task :auto_gen_config do
+        options = ['--auto-gen-config'].concat patterns
+        require 'benchmark'
+        result = 0
+        cli = RuboCop::CLI.new
+        time = Benchmark.realtime do
+          result = cli.run(options)
+        end
+        puts "Finished in #{time} seconds" if cli.options[:debug]
+        abort('RuboCop failed!') if result.nonzero?
+      end
+    end
+  end
+end