active_model_serializers 0.1.0

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/active_model_serializers.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.authors       = ["José Valim", "Yehuda Katz"]
+  gem.email         = ["jose.valim@gmail.com", "wycats@gmail.com"]
+  gem.description   = %q{Making it easy to serialize models for client-side use}
+  gem.summary       = %q{Bringing consistency and object orientation to model serialization. Works great for client-side MVC frameworks!}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "active_model_serializers"
+  gem.require_paths = ["lib"]
+  gem.version       = "0.1.0"
+
+  gem.add_dependency 'activemodel', '~> 3.0'
+  gem.add_development_dependency "rails", "~> 3.0"
+end

data/lib/action_controller/serialization.rb

@@ -0,0 +1,52 @@
+module ActionController
+  # Action Controller Serialization
+  #
+  # Overrides render :json to check if the given object implements +active_model_serializer+
+  # as a method. If so, use the returned serializer instead of calling +to_json+ in the object.
+  #
+  # This module also provides a serialization_scope method that allows you to configure the
+  # +serialization_scope+ of the serializer. Most apps will likely set the +serialization_scope+
+  # to the current user:
+  #
+  #    class ApplicationController < ActionController::Base
+  #      serialization_scope :current_user
+  #    end
+  #
+  # If you need more complex scope rules, you can simply override the serialization_scope:
+  #
+  #    class ApplicationController < ActionController::Base
+  #      private
+  #
+  #      def serialization_scope
+  #        current_user
+  #      end
+  #    end
+  #
+  module Serialization
+    extend ActiveSupport::Concern
+
+    include ActionController::Renderers
+
+    included do
+      class_attribute :_serialization_scope
+      self._serialization_scope = :current_user
+    end
+
+    def serialization_scope
+      send(_serialization_scope)
+    end
+
+    def _render_option_json(json, options)
+      if json.respond_to?(:active_model_serializer) && (serializer = json.active_model_serializer)
+        json = serializer.new(json, serialization_scope, options)
+      end
+      super
+    end
+
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
+      end
+    end
+  end
+end

data/lib/active_model/serializer.rb

@@ -0,0 +1,353 @@
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/anonymous"
+
+module ActiveModel
+  # Active Model Array Serializer
+  #
+  # It serializes an array checking if each element that implements
+  # the +active_model_serializer+ method passing down the current scope.
+  class ArraySerializer
+    attr_reader :object, :scope
+
+    def initialize(object, scope, options={})
+      @object, @scope, @options = object, scope, options
+      @hash = options[:hash]
+    end
+
+    def serializable_array
+      @object.map do |item|
+        if item.respond_to?(:active_model_serializer) && (serializer = item.active_model_serializer)
+          serializer.new(item, scope, :hash => @hash)
+        else
+          item
+        end
+      end
+    end
+
+    def as_json(*args)
+      @hash = {}
+      array = serializable_array.as_json(*args)
+
+      if root = @options[:root]
+        @hash.merge!(root => array)
+      else
+        array
+      end
+    end
+  end
+
+  # Active Model Serializer
+  #
+  # Provides a basic serializer implementation that allows you to easily
+  # control how a given object is going to be serialized. On initialization,
+  # it expects to object as arguments, a resource and a scope. For example,
+  # one may do in a controller:
+  #
+  #     PostSerializer.new(@post, current_user).to_json
+  #
+  # The object to be serialized is the +@post+ and the scope is +current_user+.
+  #
+  # We use the scope to check if a given attribute should be serialized or not.
+  # For example, some attributes maybe only be returned if +current_user+ is the
+  # author of the post:
+  #
+  #     class PostSerializer < ActiveModel::Serializer
+  #       attributes :title, :body
+  #       has_many :comments
+  #
+  #       private
+  #
+  #       def attributes
+  #         hash = super
+  #         hash.merge!(:email => post.email) if author?
+  #         hash
+  #       end
+  #
+  #       def author?
+  #         post.author == scope
+  #       end
+  #     end
+  #
+  class Serializer
+    module Associations #:nodoc:
+      class Config < Struct.new(:name, :options) #:nodoc:
+        def serializer
+          options[:serializer]
+        end
+
+        def key
+          options[:key] || name
+        end
+
+        protected
+
+        def find_serializable(object, scope, context, options)
+          if serializer
+            serializer.new(object, scope, options)
+          elsif object.respond_to?(:active_model_serializer) && (ams = object.active_model_serializer)
+            ams.new(object, scope, options)
+          else
+            object
+          end
+        end
+      end
+
+      class HasMany < Config #:nodoc:
+        def serialize(collection, scope, context, options)
+          array = collection.map do |item|
+            find_serializable(item, scope, context, options).as_json(:root => false)
+          end
+          { key => array }
+        end
+
+        def serialize_ids(collection, scope)
+          # Use pluck or select_columns if available
+          # return collection.ids if collection.respond_to?(:ids)
+
+          array = collection.map do |item|
+            item.read_attribute_for_serialization(:id)
+          end
+
+          { key => array }
+        end
+      end
+
+      class HasOne < Config #:nodoc:
+        def serialize(object, scope, context, options)
+          { key => object && find_serializable(object, scope, context, options).as_json(:root => false) }
+        end
+
+        def serialize_ids(object, scope)
+          { key => object && object.read_attribute_for_serialization(:id) }
+        end
+      end
+    end
+
+    class_attribute :_attributes
+    self._attributes = {}
+
+    class_attribute :_associations
+    self._associations = []
+
+    class_attribute :_root
+    class_attribute :_embed
+    self._embed = :objects
+    class_attribute :_root_embed
+
+    class << self
+      # Define attributes to be used in the serialization.
+      def attributes(*attrs)
+        self._attributes = _attributes.dup
+
+        attrs.each do |attr|
+          self._attributes[attr] = attr
+        end
+      end
+
+      def attribute(attr, options={})
+        self._attributes = _attributes.merge(attr => options[:key] || attr)
+      end
+
+      def associate(klass, attrs) #:nodoc:
+        options = attrs.extract_options!
+        self._associations += attrs.map do |attr|
+          unless method_defined?(attr)
+            class_eval "def #{attr}() object.#{attr} end", __FILE__, __LINE__
+          end
+          klass.new(attr, options)
+        end
+      end
+
+      # Defines an association in the object should be rendered.
+      #
+      # The serializer object should implement the association name
+      # as a method which should return an array when invoked. If a method
+      # with the association name does not exist, the association name is
+      # dispatched to the serialized object.
+      def has_many(*attrs)
+        associate(Associations::HasMany, attrs)
+      end
+
+      # Defines an association in the object should be rendered.
+      #
+      # The serializer object should implement the association name
+      # as a method which should return an object when invoked. If a method
+      # with the association name does not exist, the association name is
+      # dispatched to the serialized object.
+      def has_one(*attrs)
+        associate(Associations::HasOne, attrs)
+      end
+
+      # Return a schema hash for the current serializer. This information
+      # can be used to generate clients for the serialized output.
+      #
+      # The schema hash has two keys: +attributes+ and +associations+.
+      #
+      # The +attributes+ hash looks like this:
+      #
+      #     { :name => :string, :age => :integer }
+      #
+      # The +associations+ hash looks like this:
+      #
+      #     { :posts => { :has_many => :posts } }
+      #
+      # If :key is used:
+      #
+      #     class PostsSerializer < ActiveModel::Serializer
+      #       has_many :posts, :key => :my_posts
+      #     end
+      #
+      # the hash looks like this:
+      #
+      #     { :my_posts => { :has_many => :posts }
+      #
+      # This information is extracted from the serializer's model class,
+      # which is provided by +SerializerClass.model_class+.
+      #
+      # The schema method uses the +columns_hash+ and +reflect_on_association+
+      # methods, provided by default by ActiveRecord. You can implement these
+      # methods on your custom models if you want the serializer's schema method
+      # to work.
+      #
+      # TODO: This is currently coupled to Active Record. We need to
+      # figure out a way to decouple those two.
+      def schema
+        klass = model_class
+        columns = klass.columns_hash
+
+        attrs = _attributes.inject({}) do |hash, (name,key)|
+          column = columns[name.to_s]
+          hash.merge key => column.type
+        end
+
+        associations = _associations.inject({}) do |hash, association|
+          model_association = klass.reflect_on_association(association.name)
+          hash.merge association.key => { model_association.macro => model_association.name }
+        end
+
+        { :attributes => attrs, :associations => associations }
+      end
+
+      # The model class associated with this serializer.
+      def model_class
+        name.sub(/Serializer$/, '').constantize
+      end
+
+      # Define how associations should be embedded.
+      #
+      #   embed :objects               # Embed associations as full objects
+      #   embed :ids                   # Embed only the association ids
+      #   embed :ids, :include => true # Embed the association ids and include objects in the root
+      #
+      def embed(type, options={})
+        self._embed = type
+        self._root_embed = true if options[:include]
+      end
+
+      # Defines the root used on serialization. If false, disables the root.
+      def root(name)
+        self._root = name
+      end
+
+      def inherited(klass) #:nodoc:
+        return if klass.anonymous?
+        name = klass.name.demodulize.underscore.sub(/_serializer$/, '')
+
+        klass.class_eval do
+          alias_method name.to_sym, :object
+          root name.to_sym unless self._root == false
+        end
+      end
+    end
+
+    attr_reader :object, :scope
+
+    def initialize(object, scope, options={})
+      @object, @scope, @options = object, scope, options
+      @hash = options[:hash]
+    end
+
+    # Returns a json representation of the serializable
+    # object including the root.
+    def as_json(options=nil)
+      options ||= {}
+      if root = options.fetch(:root, @options.fetch(:root, _root))
+        @hash = hash = {}
+        hash.merge!(root => serializable_hash)
+        hash
+      else
+        @hash = serializable_hash
+      end
+    end
+
+    # Returns a hash representation of the serializable
+    # object without the root.
+    def serializable_hash
+      if _embed == :ids
+        merge_associations(@hash, associations) if _root_embed
+        attributes.merge(association_ids)
+      elsif _embed == :objects
+        attributes.merge(associations)
+      else
+        attributes
+      end
+    end
+
+    # Merge associations for embed case by always adding
+    # root associations to the given hash.
+    def merge_associations(hash, associations)
+      associations.each do |key, value|
+        if hash[key]
+          hash[key] |= value
+        elsif value
+          hash[key] = value
+        end
+      end
+    end
+
+    # Returns a hash representation of the serializable
+    # object associations.
+    def associations
+      hash = {}
+
+      _associations.each do |association|
+        associated_object = send(association.name)
+        hash.merge! association.serialize(associated_object, scope, self, :hash => @hash)
+      end
+
+      hash
+    end
+
+    # Returns a hash representation of the serializable
+    # object associations ids.
+    def association_ids
+      hash = {}
+
+      _associations.each do |association|
+        associated_object = send(association.name)
+        hash.merge! association.serialize_ids(associated_object, scope)
+      end
+
+      hash
+    end
+
+    # Returns a hash representation of the serializable
+    # object attributes.
+    def attributes
+      hash = {}
+
+      _attributes.each do |name,key|
+        hash[key] = @object.read_attribute_for_serialization(name)
+      end
+
+      hash
+    end
+  end
+end
+
+class Array
+  # Array uses ActiveModel::ArraySerializer.
+  def active_model_serializer
+    ActiveModel::ArraySerializer
+  end
+end

data/lib/active_model_serializers.rb

@@ -0,0 +1,48 @@
+require "active_support"
+require "active_support/core_ext/string/inflections"
+require "active_model"
+require "active_model/serializer"
+
+module ActiveModel::SerializerSupport
+  extend ActiveSupport::Concern
+
+  module ClassMethods #:nodoc:
+    if "".respond_to?(:safe_constantize)
+      def active_model_serializer
+        @active_model_serializer ||= "#{self.name}Serializer".safe_constantize
+      end
+    else
+      def active_model_serializer
+        return @active_model_serializer if defined?(@active_model_serializer)
+
+        begin
+          @active_model_serializer = "#{self.name}Serializer".constantize
+        rescue NameError => e
+          raise unless e.message =~ /uninitialized constant/
+        end
+      end
+    end
+  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
+end
+
+ActiveSupport.on_load(:active_record) do
+  include ActiveModel::SerializerSupport
+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