active_model_serializers 0.8.3 → 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,95 +1,63 @@
-require "active_support"
-require "active_support/core_ext/string/inflections"
-require "active_support/notifications"
-require "active_model"
-require "active_model/array_serializer"
-require "active_model/serializer"
-require "active_model/serializer/associations"
-require "set"
-
-if defined?(Rails)
-  module ActiveModel
-    class Railtie < Rails::Railtie
-      generators do |app|
-        app ||= Rails.application # Rails 3.0.x does not yield `app`
-
-        Rails::Generators.configure!(app.config.generators)
-        Rails::Generators.hidden_namespaces.uniq!
-        require_relative "generators/resource_override"
-      end
-
-      initializer "include_routes.active_model_serializer" do |app|
-        ActiveSupport.on_load(:active_model_serializers) do
-          include app.routes.url_helpers
-        end
-      end
+# frozen_string_literal: true
+
+require 'active_model'
+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
 
-      initializer "caching.active_model_serializer" do |app|
-        ActiveModel::Serializer.perform_caching = app.config.action_controller.perform_caching
-        ActiveModel::ArraySerializer.perform_caching = app.config.action_controller.perform_caching
+  class << self; attr_accessor :logger; end
+  self.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
 
-        ActiveModel::Serializer.cache = Rails.cache
-        ActiveModel::ArraySerializer.cache = Rails.cache
-      end
-    end
+  def self.config
+    ActiveModel::Serializer.config
   end
-end
 
-module ActiveModel::SerializerSupport
-  extend ActiveSupport::Concern
+  # 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
 
-  module ClassMethods #:nodoc:
-    if "".respond_to?(:safe_constantize)
-      def active_model_serializer
-        "#{self.name}Serializer".safe_constantize
-      end
-    else
-      def active_model_serializer
-        begin
-          "#{self.name}Serializer".constantize
-        rescue NameError => e
-          raise unless e.message =~ /uninitialized constant/
-        end
-      end
-    end
+    [file, lineno]
   end
 
-  # Returns a model serializer for this object considering its namespace.
-  def active_model_serializer
-    self.class.active_model_serializer
+  # 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
 
-  alias :read_attribute_for_serialization :send
-end
-
-module ActiveModel::ArraySerializerSupport
-  def active_model_serializer
-    ActiveModel::ArraySerializer
+  def self.silence_warnings
+    original_verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbose
   end
-end
-
-Array.send(:include, ActiveModel::ArraySerializerSupport)
-Set.send(:include, ActiveModel::ArraySerializerSupport)
 
-{
-  :active_record => 'ActiveRecord::Relation',
-  :mongoid => 'Mongoid::Criteria'
-}.each do |orm, rel_class|
-  ActiveSupport.on_load(orm) do
-    include ActiveModel::SerializerSupport
-    rel_class.constantize.send(:include, ActiveModel::ArraySerializerSupport)
+  def self.eager_load!
+    super
+    ActiveModel::Serializer.eager_load!
   end
-end
 
-begin
-  require 'action_controller'
-  require 'action_controller/serialization'
-
-  ActiveSupport.on_load(:action_controller) do
-    include ::ActionController::Serialization
-  end
-rescue LoadError => ex
-  # rails on installed, continuing
+  require 'active_model/serializer/version'
+  require 'active_model/serializer'
+  require 'active_model/serializable_resource'
+  require 'active_model_serializers/railtie' if defined?(::Rails::Railtie)
 end
-
-ActiveSupport.run_load_hooks(:active_model_serializers, ActiveModel::Serializer)

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

data/lib/generators/rails/templates/serializer.rb.erb

@@ -0,0 +1,8 @@
+<% module_namespacing do -%>
+class <%= class_name %>Serializer < <%= parent_class_name %>
+  attributes <%= attributes_names.map(&:inspect).join(", ") %>
+<% association_names.each do |attribute| -%>
+  has_one :<%= attribute %>
+<% end -%>
+end
+<% end -%>

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