active_model_serializers_rails_2.3 0.9.0.alpha1 → 0.9.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0bf1627e3e77f67d91a472d7973d66c3a8ca726b
+  data.tar.gz: 905a98aa09e0e84a9ae4b0931f55d39fe1e0b8cd
+SHA512:
+  metadata.gz: 3984baa7ec037bd7e4faf376127623bafac0b8de7fbb08f48e1effab5240968bce85a217104be9c55ad84204f170cc27860aa53b627a7a9eb8d034222a0b9048
+  data.tar.gz: c4607f4816f99fd7d913a881937d0a6814482376e404877bd71bcc1db494b395058a70cb7a177f0fb92774ec56fef586db293cb830cebd9060c518f8dbb5b35c

data/README.md

@@ -10,19 +10,9 @@ This is a backport of the ActiveModel::Serializers gem to be compatible with
 Rails 2.3. The following features have been removed:
 
 * Controller `render` method support. This means you'll need to instantiate
-the serializer yourself and pass it to `render`. E.g. `render :json => FooSerializer.new(foo, scope: user)`
+the serializer yourself and pass it to `render`. E.g. `render :json => FooSerializer.new(foo)`
+* `current_user` and such support. Might be baked in later.
 * Generators are gone as well.
-* Probably won't be supported for a long amount of time. Please do your best to upgrade
-to rails 3.2+ as soon as possible. Feel free to open an issue whenever I run
-too far behind upstream's master branch.
-
-## Rails 2-3- 0.9.0
-
-**Rails 2-3 is under development, there are some incompatible changes with the current stable release.**
-
-Since `0.8` there is no `options` accessor in the serializers. Some issues and pull-requests are attemps to bring back the ability to use Rails url helpers in the serializers, but nothing is really settled yet.
-
-If you want to read the stable documentation visit [0.8 README](https://github.com/rails-api/active_model_serializers/blob/0-8-stable/README.md)
 
 ## Purpose
 
@@ -43,7 +33,7 @@ The easiest way to install `ActiveModel::Serializers` is to add it to your
 `Gemfile`:
 
 ```ruby
-gem "active_model_serializers_rails2.3", git: "https://github.com/fivetanley/active_model_serializers", branch: 'rails-2.3'
+gem "active_model_serializers_rails2.3"
 ```
 
 Then, install it on the command line:
@@ -85,6 +75,10 @@ Currently `ActiveModel::Serializers` expects objects to implement
 read\_attribute\_for\_serialization. That's all you need to do to have
 your POROs supported. 
 
+# ActiveModel::Serializer
+
+All new serializers descend from ActiveModel::Serializer
+
 # render :json
 
 In your controllers, when you use `render :json`, Rails will now first search
@@ -168,20 +162,6 @@ To specify a custom serializer for the items within an array:
 render json: @posts, each_serializer: FancyPostSerializer
 ```
 
-## Render independently
-
-By default the setting of serializer is in controller as described above which is the
-recommeneded way. However, there may be cases you need to render the json object elsewhere
-say in a helper or a view when controller is only for main object.
-
-Then you can render the serialized JSON independently.
-
-```ruby
-def current_user_as_json_helper
-  CurrentUserSerializer.new(current_user).to_json
-end
-```
-
 ## Disabling the root element
 
 You have 4 options to disable the root element, each with a slightly different scope:
@@ -287,9 +267,9 @@ authorization context to your serializer. By default, the context
 is the current user of your application, but this
 [can be customized](#customizing-scope).
 
-Serializers provides a method named `filter`, which should return an array
-used to determine what attributes and associations should be included in the output.
-This is typically used to customize output based on `current_user`. For example:
+Serializers provides a method named `filter` used to determine what
+attributes and associations should be included in the output. This is
+typically used to customize output based on `current_user`. For example:
 
 ```ruby
 class PostSerializer < ActiveModel::Serializer
@@ -306,8 +286,7 @@ end
 ```
 
 And it's also safe to mutate keys argument by doing keys.delete(:author)
-in case you want to avoid creating two extra arrays. Note that if you do an
-in-place modification, you still need to return the modified array.
+in case you want to avoid creating two extra arrays.
 
 If you would like the key in the outputted JSON to be different from its name
 in ActiveRecord, you can declare the attribute with the different name
@@ -748,29 +727,6 @@ end
 
 The caching interface uses `Rails.cache` under the hood.
 
-# ApplicationSerializer
-
-By default, new serializers descend from ActiveModel::Serializer. However, if you wish to share behaviour across your serializers you can create an ApplicationSerializer at ```app/serializers/application_serializer.rb```:
-
-```ruby
-class ApplicationSerializer < ActiveModel::Serializer
-end
-```
-
-Any newly generated serializers will automatically descend from ApplicationSerializer.
-
-```
-$ rails g serializer post
-```
-
-now generates:
-
-```ruby
-class PostSerializer < ApplicationSerializer
-  attributes :id
-end
-````
-
 # Design and Implementation Guidelines
 
 ## Keep it Simple

data/lib/active_model/array_serializer.rb

@@ -14,47 +14,22 @@ module ActiveModel
 
     def initialize(object, options={})
       @object          = object
-      @scope           = options[:scope]
-      @root            = options.fetch(:root, self.class._root)
+      @root            = options[:root]
+      @root            = self.class._root if @root.nil?
+      @root            = options[:resource_name] if @root.nil?
       @meta_key        = options[:meta_key] || :meta
       @meta            = options[@meta_key]
       @each_serializer = options[:each_serializer]
-      @resource_name   = options[:resource_name]
+      @options         = options.merge(root: nil)
     end
-    attr_accessor :object, :scope, :root, :meta_key, :meta
+    attr_accessor :object, :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
+    def serializable_array
       @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
+        serializer = @each_serializer || Serializer.serializer_for(item) || DefaultSerializer
+        serializer.new(item, @options).serializable_object
       end
     end
+    alias_method :serializable_object, :serializable_array
   end
 end

data/lib/active_model/as_json_overrides.rb

@@ -0,0 +1,6 @@
+class Struct
+  def as_json(options = nil)
+    Hash[members.zip(values)]
+  end
+end
+

data/lib/active_model/default_serializer.rb

@@ -1,27 +1,18 @@
-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={})
+    def serializable_hash(*)
       return nil if @object.nil?
-      if @object.is_a?(Struct)
-        Hash[@object.members.zip(@object.values)]
-      else
-        @object.as_json
-      end
+      @object.as_json
     end
-    alias serializable_hash as_json
-    alias serializable_object as_json
+    alias serializable_object serializable_hash
   end
 end

data/lib/active_model/serializable.rb

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

data/lib/active_model/serializer/associations.rb

@@ -13,84 +13,46 @@ module ActiveModel
 
         @name          = name.to_s
         @options       = options
-        self.embed     = options.fetch(:embed) { CONFIG.embed }
+        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
+        self.serializer_class = @options[: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
+      attr_reader :name, :embed_ids, :embed_objects, :serializer_class
+      attr_accessor :embed_in_root, :embed_key, :key, :embedded_key, :options
       alias embed_ids? embed_ids
       alias embed_objects? embed_objects
       alias embed_in_root? embed_in_root
 
+      def serializer_class=(serializer)
+        @serializer_class = serializer.is_a?(String) ? serializer.constantize : serializer
+      end
+
       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))
+      def build_serializer(object)
+        @serializer_class ||= Serializer.serializer_for(object) || DefaultSerializer
+        @serializer_class.new(object, @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?
+        def initialize(*args)
           super
+          @key  ||= "#{name}_id"
         end
       end
 
       class HasMany < Association
-        def initialize(name, *args)
+        def initialize(*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)
+          @key ||= "#{name.singularize}_ids"
         end
       end
     end

data/lib/active_model/serializer/railtie.rb

@@ -1,9 +1,9 @@
 module ActiveModel
   class Railtie < Rails::Railtie
     initializer 'generators' do |app|
-      app.load_generators
+      require 'rails/generators'
       require 'active_model/serializer/generators/serializer/serializer_generator'
-      require 'active_model/serializer/generators/serializer/scaffold_controller_generator'
+      Rails::Generators.configure!(app.config.generators)
       require 'active_model/serializer/generators/resource_override'
     end
   end

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = '0.9.0.alpha1'
+    VERSION = "0.9.0.pre1"
   end
 end

data/lib/active_model/serializer.rb

@@ -15,33 +15,13 @@ 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
+        base._attributes = []
+        base._associations = {}
       end
 
       def setup
@@ -81,7 +61,7 @@ end
           if resource.respond_to?(:to_ary)
             ArraySerializer
           else
-            safe_constantize "#{resource.class.name}Serializer"
+            "#{resource.class.name}Serializer".safe_constantize
           end
         end
       end
@@ -128,21 +108,19 @@ 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]
+      @object   = object
+      @scope    = options[:scope]
+      self.root = options[:root]
+      @meta_key = options[:meta_key] || :meta
+      @meta     = options[@meta_key]
     end
-    attr_accessor :object, :scope, :root, :meta_key, :meta
+    attr_accessor :object, :scope, :meta_key, :meta
+    attr_reader :root
 
-    def json_key
-      if root == true || root.nil?
-        self.class.root_name
-      else
-        root
-      end
+    def root=(root)
+      @root = root
+      @root = self.class._root if @root.nil?
+      @root = self.class.root_name if @root == true || @root.nil?
     end
 
     def attributes
@@ -169,34 +147,31 @@ end
       keys
     end
 
+    def serializable_data
+      embedded_in_root_associations.merge!(super)
+    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
+            hash[association.embedded_key] = serialize association
           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
+      associated_data = send(association.name)
+      if associated_data.respond_to?(:to_ary) &&
+         !(association.serializer_class &&
+           association.serializer_class <= ArraySerializer)
+        associated_data.map { |elem| association.build_serializer(elem).serializable_hash }
+      else
+        association.build_serializer(associated_data).serializable_object
+      end
     end
 
     def serialize_ids(association)
@@ -208,13 +183,11 @@ end
       end
     end
 
-    def serializable_object(options={})
+    def serializable_hash(options={})
       return nil if object.nil?
       hash = attributes
       hash.merge! associations
-      @wrap_in_array ? [hash] : hash
     end
-    alias_method :serializable_hash, :serializable_object
+    alias_method :serializable_object, :serializable_hash
   end
-
 end

data/lib/active_model_serializers.rb

@@ -1,26 +1,10 @@
 require 'active_support'
-require 'active_record'
+require 'active_model/as_json_overrides'
 require 'active_model/serializer'
 require 'active_model/serializer_support'
 require 'active_model/serializer/version'
-require 'active_model/serializer/railtie' if defined?(Rails) && defined?(Rails::Railtie)
+require 'active_model/serializer/railtie' if defined?(Rails)
 
-ActiveModel::Errors = ActiveRecord::Errors #fix for authlogic gem
-
-module ActiveSupport
-  module Inflector
-    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
-  end
-end
 begin
   require 'action_controller'
   require 'action_controller/serialization'

data/test/coverage_setup.rb

@@ -1,15 +1,12 @@
-begin
-  require 'simplecov'
-  require 'coveralls'
+require 'simplecov'
+require 'coveralls'
 
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
 
-  SimpleCov.start do
-    add_group "lib", "lib"
-    add_group "test", "test"
-  end
-rescue LoadError
+SimpleCov.start do
+  add_group "lib", "lib"
+  add_group "test", "test"
 end

data/test/fixtures/active_record.rb

@@ -80,13 +80,13 @@ ARPost.create(title: 'New post',
 
   short_tag = post.ar_tags.create(name: 'short')
   whiny_tag = post.ar_tags.create(name: 'whiny')
-  happy_tag = ARTag.create(name: 'happy')
+  happy_tag = post.ar_tags.create(name: 'happy')
 
   post.ar_comments.create(body: 'what a dumb post').tap do |comment|
-    comment.ar_tags.concat happy_tag, whiny_tag
+    comment.ar_tags.concat short_tag, whiny_tag
   end
 
   post.ar_comments.create(body: 'i liked it').tap do |comment|
-    comment.ar_tags.concat happy_tag, short_tag
+    comment.ar_tags.concat short_tag, happy_tag
   end
 end

data/test/integration/active_record/active_record_test.rb

@@ -3,7 +3,7 @@ require 'fixtures/active_record'
 
 module ActiveModel
   class Serializer
-    class ActiveRecordTest < Minitest::Test
+    class ActiveRecordTest < ActiveRecord::TestCase
       def setup
         @post = ARPost.first
       end
@@ -14,9 +14,9 @@ module ActiveModel
         assert_equal({
           'ar_post' => {
             title: 'New post', body: 'A body!!!',
-            ar_comments: [{ body: 'what a dumb post', ar_tags: [{ name: 'happy' }, { name: 'whiny' }] },
-                          { body: 'i liked it', ar_tags: [{:name=>"happy"}, {:name=>"short"}] }],
-            ar_tags: [{ name: 'short' }, { name: 'whiny' }],
+            ar_comments: [{ body: 'what a dumb post', ar_tags: [{ name: 'short' }, { name: 'whiny' }] },
+                          { body: 'i liked it', ar_tags: [{:name=>"short"}, {:name=>"happy"}] }],
+            ar_tags: [{ name: 'short' }, { name: 'whiny' }, { name: 'happy' }],
             ar_section: { 'name' => 'ruby' }
           }
         }, post_serializer.as_json)
@@ -30,7 +30,7 @@ module ActiveModel
             'ar_post' => {
               title: 'New post', body: 'A body!!!',
               'ar_comment_ids' => [1, 2],
-              'ar_tag_ids' => [1, 2],
+              'ar_tag_ids' => [1, 2, 3],
               'ar_section_id' => 1
             }
           }, post_serializer.as_json)
@@ -41,36 +41,34 @@ module ActiveModel
         post_serializer = ARPostSerializer.new(@post)
 
         embed(ARPostSerializer, embed: :ids, embed_in_root: true) do
-          embed(ARCommentSerializer, embed: :ids, embed_in_root: true) do
-            assert_equal({
-              'ar_post' => {
-                title: 'New post', body: 'A body!!!',
-                'ar_comment_ids' => [1, 2],
-                'ar_tag_ids' => [1, 2],
-                'ar_section_id' => 1
-              },
-              ar_comments: [{ body: 'what a dumb post', 'ar_tag_ids' => [3, 2] },
-                            { body: 'i liked it', 'ar_tag_ids' => [3, 1] }],
-              ar_tags: [{ name: 'happy' }, { name: 'whiny' }, { name: 'short' }],
-              'ar_sections' => [{ 'name' => 'ruby' }]
-            }, post_serializer.as_json)
-          end
+          assert_equal({
+            'ar_post' => {
+              title: 'New post', body: 'A body!!!',
+              'ar_comment_ids' => [1, 2],
+              'ar_tag_ids' => [1, 2, 3],
+              'ar_section_id' => 1
+            },
+            ar_comments: [{ body: 'what a dumb post', ar_tags: [{ name: 'short' }, { name: 'whiny' }] },
+                          { body: 'i liked it', ar_tags: [{:name=>"short"}, {:name=>"happy"}] }],
+            ar_tags: [{ name: 'short' }, { name: 'whiny' }, { name: 'happy' }],
+            ar_section: { 'name' => 'ruby' }
+          }, post_serializer.as_json)
         end
       end
 
       private
 
-      def embed(serializer_class, options = {})
-        old_assocs = Hash[serializer_class._associations.to_a.map { |(name, association)| [name, association.dup] }]
+      def embed(klass, options = {})
+        old_assocs = Hash[ARPostSerializer._associations.to_a.map { |(name, association)| [name, association.dup] }]
 
-        serializer_class._associations.each_value do |association|
+        ARPostSerializer._associations.each_value do |association|
           association.embed = options[:embed]
           association.embed_in_root = options[:embed_in_root]
         end
 
         yield
       ensure
-        serializer_class._associations = old_assocs
+        ARPostSerializer._associations = old_assocs
       end
     end
   end