active_model_serializers_rails_2.3 0.9.0.alpha1

data/lib/active_model/array_serializer.rb

@@ -0,0 +1,60 @@
+require 'active_model/default_serializer'
+require 'active_model/serializable'
+require 'active_model/serializer'
+
+module ActiveModel
+  class ArraySerializer
+    include Serializable
+
+    class << self
+      attr_accessor :_root
+      alias root  _root=
+      alias root= _root=
+    end
+
+    def initialize(object, options={})
+      @object          = object
+      @scope           = options[:scope]
+      @root            = options.fetch(:root, self.class._root)
+      @meta_key        = options[:meta_key] || :meta
+      @meta            = options[@meta_key]
+      @each_serializer = options[:each_serializer]
+      @resource_name   = options[:resource_name]
+    end
+    attr_accessor :object, :scope, :root, :meta_key, :meta
+
+    def json_key
+      if root.nil?
+        @resource_name
+      else
+        root
+      end
+    end
+
+    def serializer_for(item)
+      serializer_class = @each_serializer || Serializer.serializer_for(item) || DefaultSerializer
+      serializer_class.new(item, scope: scope)
+    end
+
+    def serializable_object
+      @object.map do |item|
+        serializer_for(item).serializable_object
+      end
+    end
+    alias_method :serializable_array, :serializable_object
+
+    def embedded_in_root_associations
+      @object.each_with_object({}) do |item, hash|
+        serializer_for(item).embedded_in_root_associations.each_pair do |type, objects|
+          next if !objects || objects.flatten.empty?
+
+          if hash.has_key?(type)
+            hash[type].concat(objects).uniq!
+          else
+            hash[type] = objects
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_model/default_serializer.rb

@@ -0,0 +1,27 @@
+require 'active_model/serializable'
+
+module ActiveModel
+  # DefaultSerializer
+  #
+  # Provides a constant interface for all items
+  class DefaultSerializer
+    include ActiveModel::Serializable
+
+    attr_reader :object
+
+    def initialize(object, options=nil)
+      @object = object
+    end
+
+    def as_json(options={})
+      return nil if @object.nil?
+      if @object.is_a?(Struct)
+        Hash[@object.members.zip(@object.values)]
+      else
+        @object.as_json
+      end
+    end
+    alias serializable_hash as_json
+    alias serializable_object as_json
+  end
+end

data/lib/active_model/serializable.rb

@@ -0,0 +1,25 @@
+module ActiveModel
+  module Serializable
+    def as_json(options={})
+      if root = options.fetch(:root, json_key)
+        hash = { root => serializable_object }
+        hash.merge!(serializable_data)
+        hash
+      else
+        serializable_object
+      end
+    end
+
+    def serializable_data
+      embedded_in_root_associations.tap do |hash|
+        if respond_to?(:meta) && meta
+          hash[meta_key] = meta
+        end
+      end
+    end
+
+    def embedded_in_root_associations
+      {}
+    end
+  end
+end

data/lib/active_model/serializer.rb

@@ -0,0 +1,220 @@
+require 'active_record'
+require 'active_model/array_serializer'
+require 'active_model/serializable'
+require 'active_model/serializer/associations'
+require 'active_model/serializer/config'
+
+require 'thread'
+
+module ActiveRecord
+  class Base
+    alias read_attribute_for_serialization send
+  end
+end
+
+module ActiveModel
+  class Serializer
+    include Serializable
+    extend ActiveSupport::Inflector
+
+    @mutex = Mutex.new
+
+    class << self
+      def inherited(base)
+        base._root = _root
+        base._attributes = (_attributes || []).dup
+        base._associations = (_associations || {}).dup
+      end
+      def const_regexp(camel_cased_word) #:nodoc:
+        parts = camel_cased_word.split("::")
+        last  = parts.pop
+
+        parts.reverse.inject(last) do |acc, part|
+          part.empty? ? acc : "#{part}(::#{acc})?"
+        end
+      end
+      def safe_constantize(camel_cased_word)
+        begin
+          constantize(camel_cased_word)
+        rescue NameError => e
+          raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
+            e.name.to_s == camel_cased_word.to_s
+        rescue ArgumentError => e
+          raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+        end
+      end
+
+      def setup
+        @mutex.synchronize do
+          yield CONFIG
+        end
+      end
+
+      def embed(type, options={})
+        CONFIG.embed = type
+        CONFIG.embed_in_root = true if options[:embed_in_root] || options[:include]
+        ActiveSupport::Deprecation.warn <<-WARN
+** Notice: embed is deprecated. **
+The use of .embed method on a Serializer will be soon removed, as this should have a global scope and not a class scope.
+Please use the global .setup method instead:
+ActiveModel::Serializer.setup do |config|
+  config.embed = :#{type}
+  config.embed_in_root = #{CONFIG.embed_in_root || false}
+end
+        WARN
+      end
+
+      if RUBY_VERSION >= '2.0'
+        def serializer_for(resource)
+          if resource.respond_to?(:to_ary)
+            ArraySerializer
+          else
+            begin
+              Object.const_get "#{resource.class.name}Serializer"
+            rescue NameError
+              nil
+            end
+          end
+        end
+      else
+        def serializer_for(resource)
+          if resource.respond_to?(:to_ary)
+            ArraySerializer
+          else
+            safe_constantize "#{resource.class.name}Serializer"
+          end
+        end
+      end
+
+      attr_accessor :_root, :_attributes, :_associations
+      alias root  _root=
+      alias root= _root=
+
+      def root_name
+        name.demodulize.underscore.sub(/_serializer$/, '') if name
+      end
+
+      def attributes(*attrs)
+        @_attributes.concat attrs
+
+        attrs.each do |attr|
+          define_method attr do
+            object.read_attribute_for_serialization attr
+          end unless method_defined?(attr)
+        end
+      end
+
+      def has_one(*attrs)
+        associate(Association::HasOne, *attrs)
+      end
+
+      def has_many(*attrs)
+        associate(Association::HasMany, *attrs)
+      end
+
+      private
+
+      def associate(klass, *attrs)
+        options = attrs.extract_options!
+
+        attrs.each do |attr|
+          define_method attr do
+            object.send attr
+          end unless method_defined?(attr)
+
+          @_associations[attr] = klass.new(attr, options)
+        end
+      end
+    end
+
+    def initialize(object, options={})
+      @object        = object
+      @scope         = options[:scope]
+      @root          = options.fetch(:root, self.class._root)
+      @meta_key      = options[:meta_key] || :meta
+      @meta          = options[@meta_key]
+      @wrap_in_array = options[:_wrap_in_array]
+    end
+    attr_accessor :object, :scope, :root, :meta_key, :meta
+
+    def json_key
+      if root == true || root.nil?
+        self.class.root_name
+      else
+        root
+      end
+    end
+
+    def attributes
+      filter(self.class._attributes.dup).each_with_object({}) do |name, hash|
+        hash[name] = send(name)
+      end
+    end
+
+    def associations
+      associations = self.class._associations
+      included_associations = filter(associations.keys)
+      associations.each_with_object({}) do |(name, association), hash|
+        if included_associations.include? name
+          if association.embed_ids?
+            hash[association.key] = serialize_ids association
+          elsif association.embed_objects?
+            hash[association.embedded_key] = serialize association
+          end
+        end
+      end
+    end
+
+    def filter(keys)
+      keys
+    end
+
+    def embedded_in_root_associations
+      associations = self.class._associations
+      included_associations = filter(associations.keys)
+      associations.each_with_object({}) do |(name, association), hash|
+        if included_associations.include? name
+          if association.embed_in_root?
+            association_serializer = build_serializer(association)
+            hash.merge! association_serializer.embedded_in_root_associations
+
+            serialized_data = association_serializer.serializable_object
+            key = association.root_key
+            if hash.has_key?(key)
+              hash[key].concat(serialized_data).uniq!
+            else
+              hash[key] = serialized_data
+            end
+          end
+        end
+      end
+    end
+
+    def build_serializer(association)
+      object = send(association.name)
+      association.build_serializer(object, scope: scope)
+    end
+
+    def serialize(association)
+      build_serializer(association).serializable_object
+    end
+
+    def serialize_ids(association)
+      associated_data = send(association.name)
+      if associated_data.respond_to?(:to_ary)
+        associated_data.map { |elem| elem.read_attribute_for_serialization(association.embed_key) }
+      else
+        associated_data.read_attribute_for_serialization(association.embed_key) if associated_data
+      end
+    end
+
+    def serializable_object(options={})
+      return nil if object.nil?
+      hash = attributes
+      hash.merge! associations
+      @wrap_in_array ? [hash] : hash
+    end
+    alias_method :serializable_hash, :serializable_object
+  end
+
+end

data/lib/active_model/serializer/associations.rb

@@ -0,0 +1,98 @@
+require 'active_model/default_serializer'
+require 'active_model/serializer'
+
+module ActiveModel
+  class Serializer
+    class Association
+      def initialize(name, options={})
+        if options.has_key?(:include)
+          ActiveSupport::Deprecation.warn <<-WARN
+** Notice: include was renamed to embed_in_root. **
+          WARN
+        end
+
+        @name          = name.to_s
+        @options       = options
+        self.embed     = options.fetch(:embed) { CONFIG.embed }
+        @embed_in_root = options.fetch(:embed_in_root) { options.fetch(:include) { CONFIG.embed_in_root } }
+        @embed_key     = options[:embed_key] || :id
+        @key           = options[:key]
+        @embedded_key  = options[:root] || name
+
+        serializer = @options[:serializer]
+        @serializer_from_options = serializer.is_a?(String) ? serializer.constantize : serializer
+      end
+
+      attr_reader :name, :embed_ids, :embed_objects
+      attr_accessor :embed_in_root, :embed_key, :key, :embedded_key, :root_key, :serializer_from_options, :options
+      alias embed_ids? embed_ids
+      alias embed_objects? embed_objects
+      alias embed_in_root? embed_in_root
+
+      def embed=(embed)
+        @embed_ids     = embed == :id || embed == :ids
+        @embed_objects = embed == :object || embed == :objects
+      end
+
+      def serializer_from_object(object)
+        Serializer.serializer_for(object)
+      end
+
+      def default_serializer
+        DefaultSerializer
+      end
+
+      def build_serializer(object, options = {})
+        serializer_class(object).new(object, options.merge(self.options))
+      end
+
+      class HasOne < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s.pluralize
+          @key ||= "#{name}_id"
+        end
+
+        def serializer_class(object)
+          serializer_from_options || serializer_from_object(object) || default_serializer
+        end
+
+        def build_serializer(object, options = {})
+          options[:_wrap_in_array] = embed_in_root?
+          super
+        end
+      end
+
+      class HasMany < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key
+          @key ||= "#{name.to_s.singularize}_ids"
+        end
+
+        def serializer_class(object)
+          if use_array_serializer?
+            ArraySerializer
+          else
+            serializer_from_options
+          end
+        end
+
+        def options
+          if use_array_serializer?
+            { each_serializer: serializer_from_options }.merge! super
+          else
+            super
+          end
+        end
+
+        private
+
+        def use_array_serializer?
+          !serializer_from_options ||
+            serializer_from_options && !(serializer_from_options <= ArraySerializer)
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/config.rb

@@ -0,0 +1,31 @@
+module ActiveModel
+  class Serializer
+    class Config
+      def initialize(data = {})
+        @data = data
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+
+      def clear
+        @data.clear
+      end
+
+      def method_missing(name, *args)
+        name = name.to_s
+        return @data[name] if @data.include?(name)
+        match = name.match(/\A(.*?)([?=]?)\Z/)
+        case match[2]
+        when "="
+          @data[match[1]] = args.first
+        when "?"
+          !!@data[match[1]]
+        end
+      end
+    end
+
+    CONFIG = Config.new('embed' => :objects) # :nodoc:
+  end
+end