active_model_serializers 0.8.3 → 0.10.0.rc4

data/lib/active_model_serializers/logging.rb

@@ -0,0 +1,119 @@
+##
+# ActiveModelSerializers::Logging
+#
+#   https://github.com/rails/rails/blob/280654ef88/activejob/lib/active_job/logging.rb
+#
+module ActiveModelSerializers
+  module Logging
+    RENDER_EVENT = 'render.active_model_serializers'.freeze
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModelSerializers::Callbacks
+      extend Macros
+      instrument_rendering
+    end
+
+    module ClassMethods
+      def instrument_rendering
+        around_render do |args, block|
+          tag_logger do
+            notify_render do
+              block.call(args)
+            end
+          end
+        end
+      end
+    end
+
+    # Macros that can be used to customize the logging of class or instance methods,
+    # by extending the class or its singleton.
+    #
+    # Adapted from:
+    #   https://github.com/rubygems/rubygems/blob/cb28f5e991/lib/rubygems/deprecate.rb
+    #
+    # Provides a single method +notify+ to be used to declare when
+    # something a method notifies, with the argument +callback_name+ of the notification callback.
+    #
+    #     class Adapter
+    #       def self.klass_method
+    #         # ...
+    #       end
+    #
+    #       def instance_method
+    #         # ...
+    #       end
+    #
+    #       include ActiveModelSerializers::Logging::Macros
+    #       notify :instance_method, :render
+    #
+    #       class << self
+    #         extend ActiveModelSerializers::Logging::Macros
+    #         notify :klass_method, :render
+    #       end
+    #     end
+    module Macros
+      ##
+      # Simple notify method that wraps up +name+
+      # in a dummy method. It notifies on with the +callback_name+ notifier on
+      # each call to the dummy method, telling what the current serializer and adapter
+      # are being rendered.
+      # Adapted from:
+      #   https://github.com/rubygems/rubygems/blob/cb28f5e991/lib/rubygems/deprecate.rb
+      def notify(name, callback_name)
+        class_eval do
+          old = "_notifying_#{callback_name}_#{name}"
+          alias_method old, name
+          define_method name do |*args, &block|
+            run_callbacks callback_name do
+              send old, *args, &block
+            end
+          end
+        end
+      end
+    end
+
+    def notify_render(*)
+      event_name = RENDER_EVENT
+      ActiveSupport::Notifications.instrument(event_name, notify_render_payload) do
+        yield
+      end
+    end
+
+    def notify_render_payload
+      { serializer: serializer, adapter: adapter }
+    end
+
+    private
+
+    def tag_logger(*tags)
+      if ActiveModelSerializers.logger.respond_to?(:tagged)
+        tags.unshift 'active_model_serializers'.freeze unless logger_tagged_by_active_model_serializers?
+        ActiveModelSerializers.logger.tagged(*tags) { yield }
+      else
+        yield
+      end
+    end
+
+    def logger_tagged_by_active_model_serializers?
+      ActiveModelSerializers.logger.formatter.current_tags.include?('active_model_serializers'.freeze)
+    end
+
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def render(event)
+        info do
+          serializer = event.payload[:serializer]
+          adapter = event.payload[:adapter]
+          duration = event.duration.round(2)
+          "Rendered #{serializer.name} with #{adapter.class} (#{duration}ms)"
+        end
+      end
+
+      def logger
+        ActiveModelSerializers.logger
+      end
+    end
+  end
+end
+
+ActiveModelSerializers::Logging::LogSubscriber.attach_to :active_model_serializers

data/lib/active_model_serializers/model.rb

@@ -0,0 +1,39 @@
+# ActiveModelSerializers::Model is a convenient
+# serializable class to inherit from when making
+# serializable non-activerecord objects.
+module ActiveModelSerializers
+  class Model
+    include ActiveModel::Model
+    include ActiveModel::Serializers::JSON
+
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      super
+    end
+
+    # Defaults to the downcased model name.
+    def id
+      attributes.fetch(:id) { self.class.name.downcase }
+    end
+
+    # Defaults to the downcased model name and updated_at
+    def cache_key
+      attributes.fetch(:cache_key) { "#{self.class.name.downcase}/#{id}-#{updated_at.strftime("%Y%m%d%H%M%S%9N")}" }
+    end
+
+    # Defaults to the time the serializer file was modified.
+    def updated_at
+      attributes.fetch(:updated_at) { File.mtime(__FILE__) }
+    end
+
+    def read_attribute_for_serialization(key)
+      if key == :id || key == 'id'
+        attributes.fetch(key) { id }
+      else
+        attributes[key]
+      end
+    end
+  end
+end

data/lib/active_model_serializers/railtie.rb

@@ -0,0 +1,38 @@
+require 'rails/railtie'
+require 'action_controller'
+require 'action_controller/railtie'
+require 'action_controller/serialization'
+
+module ActiveModelSerializers
+  class Railtie < Rails::Railtie
+    config.to_prepare do
+      ActiveModel::Serializer.serializers_cache.clear
+    end
+
+    initializer 'active_model_serializers.action_controller' do
+      ActiveSupport.on_load(:action_controller) do
+        include(::ActionController::Serialization)
+      end
+    end
+
+    # This hook is run after the action_controller railtie has set the configuration
+    # based on the *environment* configuration and before any config/initializers are run
+    # and also before eager_loading (if enabled).
+    initializer 'active_model_serializers.set_configs', :after => 'action_controller.set_configs' do
+      ActiveModelSerializers.logger = Rails.configuration.action_controller.logger
+      ActiveModelSerializers.config.cache_store     = Rails.configuration.action_controller.cache_store
+      ActiveModelSerializers.config.perform_caching = Rails.configuration.action_controller.perform_caching
+    end
+
+    generators do |app|
+      Rails::Generators.configure!(app.config.generators)
+      Rails::Generators.hidden_namespaces.uniq!
+      require 'generators/rails/resource_override'
+    end
+
+    if Rails.env.test?
+      ActionController::TestCase.send(:include, ActiveModelSerializers::Test::Schema)
+      ActionController::TestCase.send(:include, ActiveModelSerializers::Test::Serializer)
+    end
+  end
+end

data/lib/active_model_serializers/serialization_context.rb

@@ -0,0 +1,10 @@
+module ActiveModelSerializers
+  class SerializationContext
+    attr_reader :request_url, :query_parameters
+
+    def initialize(request)
+      @request_url = request.original_url[/\A[^?]+/]
+      @query_parameters = request.query_parameters
+    end
+  end
+end

data/lib/active_model_serializers/test/schema.rb

@@ -0,0 +1,103 @@
+module ActiveModelSerializers
+  module Test
+    module Schema
+      # A Minitest Assertion that test the response is valid against a schema.
+      # @params schema_path [String] a custom schema path
+      # @params 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, response, message)
+        assert(matcher.call, matcher.message)
+      end
+
+      MissingSchema = Class.new(Errno::ENOENT)
+      InvalidSchemaError = Class.new(StandardError)
+
+      class AssertResponseSchema
+        attr_reader :schema_path, :response, :message
+
+        def initialize(schema_path, response, message)
+          require_json_schema!
+          @response = response
+          @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 ||= errors.map(&:to_s).to_sentence
+          status
+        end
+
+        protected
+
+        attr_reader :document_store
+
+        def controller_path
+          response.request.filtered_parameters[:controller]
+        end
+
+        def action
+          response.request.filtered_parameters[: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 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
+    end
+  end
+end

data/lib/active_model_serializers/test/serializer.rb

@@ -0,0 +1,125 @@
+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,7 @@
+module ActiveModelSerializers
+  module Test
+    extend ActiveSupport::Autoload
+    autoload :Serializer
+    autoload :Schema
+  end
+end

data/lib/active_model_serializers.rb

@@ -1,95 +1,23 @@
-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
-
-      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
-
-        ActiveModel::Serializer.cache = Rails.cache
-        ActiveModel::ArraySerializer.cache = Rails.cache
-      end
-    end
-  end
-end
-
-module ActiveModel::SerializerSupport
-  extend ActiveSupport::Concern
-
-  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
+require 'active_model'
+require 'active_support'
+require 'active_support/core_ext/object/with_options'
+module ActiveModelSerializers
+  extend ActiveSupport::Autoload
+  autoload :Model
+  autoload :Callbacks
+  autoload :Deserialization
+  autoload :Logging
+  autoload :Test
+
+  class << self; attr_accessor :logger; end
+  self.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+  def self.config
+    ActiveModel::Serializer.config
   end
 
-  # Returns a model serializer for this object considering its namespace.
-  def active_model_serializer
-    self.class.active_model_serializer
-  end
-
-  alias :read_attribute_for_serialization :send
+  require 'active_model/serializer/version'
+  require 'active_model/serializer'
+  require 'active_model/serializable_resource'
+  require 'active_model_serializers/railtie' if defined?(::Rails)
 end
-
-module ActiveModel::ArraySerializerSupport
-  def active_model_serializer
-    ActiveModel::ArraySerializer
-  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)
-  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
-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,10 @@
+require 'rails/generators'
+require 'rails/generators/rails/resource/resource_generator'
+
+module Rails
+  module Generators
+    class ResourceGenerator
+      hook_for :serializer, default: true, boolean: true
+    end
+  end
+end

data/lib/generators/rails/serializer_generator.rb

@@ -0,0 +1,36 @@
+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 defined?(::ApplicationSerializer)
+          '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,14 @@
+# 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::ActiveModelSerializers
+  extend ActiveSupport::Concern
+
+  included do
+    formatter :json, Grape::Formatters::ActiveModelSerializers
+    helpers Grape::Helpers::ActiveModelSerializers
+  end
+end

data/lib/grape/formatters/active_model_serializers.rb

@@ -0,0 +1,15 @@
+# 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
+module Grape
+  module Formatters
+    module ActiveModelSerializers
+      def self.call(resource, env)
+        serializer_options = {}
+        serializer_options.merge!(env[:active_model_serializer_options]) if env[:active_model_serializer_options]
+        ActiveModel::SerializableResource.new(resource, serializer_options).to_json
+      end
+    end
+  end
+end

data/lib/grape/helpers/active_model_serializers.rb

@@ -0,0 +1,16 @@
+# 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