active_model_serializers_rails_2.3 0.9.0.pre1 → 0.9.0.pre2

data/README.md

@@ -10,9 +10,17 @@ 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)`
-* `current_user` and such support. Might be baked in later.
+the serializer yourself and pass it to `render`. E.g. `render :json => FooSerializer.new(foo, scope: user)`
 * 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.**
+
+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
 
@@ -33,7 +41,7 @@ The easiest way to install `ActiveModel::Serializers` is to add it to your
 `Gemfile`:
 
 ```ruby
-gem "active_model_serializers_rails2.3"
+gem "active_model_serializers_rails2.3", git: "https://github.com/fivetanley/active_model_serializers", branch: 'rails-2.3'
 ```
 
 Then, install it on the command line:

data/lib/active_model/array_serializer.rb

@@ -14,9 +14,7 @@ module ActiveModel
 
     def initialize(object, options={})
       @object          = object
-      @root            = options[:root]
-      @root            = self.class._root if @root.nil?
-      @root            = options[:resource_name] if @root.nil?
+      @root            = options.fetch(:root, self.class._root)
       @meta_key        = options[:meta_key] || :meta
       @meta            = options[@meta_key]
       @each_serializer = options[:each_serializer]
@@ -24,12 +22,30 @@ module ActiveModel
     end
     attr_accessor :object, :root, :meta_key, :meta
 
+    def json_key
+      if root.nil?
+        @options[:resource_name]
+      else
+        root
+      end
+    end
+
+    def serializer_for(item)
+      serializer_class = @each_serializer || Serializer.serializer_for(item) || DefaultSerializer
+      serializer_class.new(item, @options)
+    end
+
     def serializable_array
       @object.map do |item|
-        serializer = @each_serializer || Serializer.serializer_for(item) || DefaultSerializer
-        serializer.new(item, @options).serializable_object
+        serializer_for(item).serializable_object
       end
     end
     alias_method :serializable_object, :serializable_array
+
+    def embedded_in_root_associations
+      @object.each_with_object({}) do |item, hash|
+        hash.merge!(serializer_for(item).embedded_in_root_associations)
+      end
+    end
   end
 end

data/lib/active_model/default_serializer.rb

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

data/lib/active_model/serializable.rb

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

@@ -15,6 +15,7 @@ end
 module ActiveModel
   class Serializer
     include Serializable
+    extend ActiveSupport::Inflector
 
     @mutex = Mutex.new
 
@@ -23,6 +24,24 @@ module ActiveModel
         base._attributes = []
         base._associations = {}
       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
@@ -61,7 +80,7 @@ end
           if resource.respond_to?(:to_ary)
             ArraySerializer
           else
-            "#{resource.class.name}Serializer".safe_constantize
+            safe_constantize "#{resource.class.name}Serializer"
           end
         end
       end
@@ -110,17 +129,18 @@ end
     def initialize(object, options={})
       @object   = object
       @scope    = options[:scope]
-      self.root = options[:root]
+      @root     = options.fetch(:root, self.class._root)
       @meta_key = options[:meta_key] || :meta
       @meta     = options[@meta_key]
     end
-    attr_accessor :object, :scope, :meta_key, :meta
-    attr_reader :root
+    attr_accessor :object, :scope, :meta_key, :meta, :root
 
-    def root=(root)
-      @root = root
-      @root = self.class._root if @root.nil?
-      @root = self.class.root_name if @root == true || @root.nil?
+    def json_key
+      if root == true || root.nil?
+        self.class.root_name
+      else
+        root
+      end
     end
 
     def attributes
@@ -137,7 +157,8 @@ end
           if association.embed_ids?
             hash[association.key] = serialize_ids association
           elsif association.embed_objects?
-            hash[association.embedded_key] = serialize association
+            associated_data = send(association.name)
+            hash[association.embedded_key] = serialize(association, associated_data)
           end
         end
       end
@@ -147,31 +168,21 @@ 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?
-            hash[association.embedded_key] = serialize association
+            associated_data = Array(send(association.name))
+            hash[association.root_key] = serialize(association, associated_data)
           end
         end
       end
     end
 
-    def serialize(association)
-      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
+    def serialize(association, object)
+      association.build_serializer(object, scope: scope).serializable_object
     end
 
     def serialize_ids(association)
@@ -190,4 +201,5 @@ end
     end
     alias_method :serializable_object, :serializable_hash
   end
+
 end

data/lib/active_model/serializer/associations.rb

@@ -19,40 +19,65 @@ module ActiveModel
         @key           = options[:key]
         @embedded_key  = options[:root] || name
 
-        self.serializer_class = @options[:serializer]
+        serializer = @options[:serializer]
+        @serializer_class = serializer.is_a?(String) ? serializer.constantize : serializer
       end
 
-      attr_reader :name, :embed_ids, :embed_objects, :serializer_class
-      attr_accessor :embed_in_root, :embed_key, :key, :embedded_key, :options
+      attr_reader :name, :embed_ids, :embed_objects
+      attr_accessor :embed_in_root, :embed_key, :key, :embedded_key, :root_key, :serializer_class, :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 build_serializer(object)
-        @serializer_class ||= Serializer.serializer_for(object) || DefaultSerializer
-        @serializer_class.new(object, @options)
+      def build_serializer(object, options = {})
+        @serializer_class.new(object, options.merge(@options))
+      end
+
+      private
+
+      def use_array_serializer!
+        @options.merge!(each_serializer: @serializer_class)
+        @serializer_class = ArraySerializer
       end
 
       class HasOne < Association
-        def initialize(*args)
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s.pluralize
+          @key ||= "#{name}_id"
+        end
+
+        def build_serializer(object, options = {})
+          if object.respond_to?(:to_ary)
+            use_array_serializer!
+          else
+            @serializer_class ||= Serializer.serializer_for(object) || DefaultSerializer
+          end
+
           super
-          @key  ||= "#{name}_id"
         end
       end
 
       class HasMany < Association
-        def initialize(*args)
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key
+          @key ||= "#{name.to_s.singularize}_ids"
+        end
+
+        def build_serializer(object, options = {})
+          if @serializer_class && !(@serializer_class <= ArraySerializer)
+            use_array_serializer!
+          else
+            @serializer_class ||= ArraySerializer
+          end
+
           super
-          @key ||= "#{name.singularize}_ids"
         end
       end
     end

data/lib/active_model/serializer/generators/serializer/scaffold_controller_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+require 'rails/generators/rails/scaffold_controller/scaffold_controller_generator'
+
+module Rails
+  module Generators
+    class ScaffoldControllerGenerator
+      if Rails::VERSION::MAJOR >= 4
+        source_root File.expand_path('../templates', __FILE__)
+
+        hook_for :serializer, default: true
+      end
+    end
+  end
+end

data/lib/active_model/serializer/generators/serializer/templates/controller.rb

@@ -0,0 +1,93 @@
+<% if namespaced? -%>
+require_dependency "<%= namespaced_file_path %>/application_controller"
+
+<% end -%>
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  before_action :set_<%= singular_table_name %>, only: [:show, :edit, :update, :destroy]
+
+  # GET <%= route_url %>
+  # GET <%= route_url %>.json
+  def index
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: <%= "@#{plural_table_name}" %> }
+    end
+  end
+
+  # GET <%= route_url %>/1
+  # GET <%= route_url %>/1.json
+  def show
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: <%= "@#{singular_table_name}" %> }
+    end
+  end
+
+  # GET <%= route_url %>/new
+  def new
+    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
+  end
+
+  # GET <%= route_url %>/1/edit
+  def edit
+  end
+
+  # POST <%= route_url %>
+  # POST <%= route_url %>.json
+  def create
+    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
+
+    respond_to do |format|
+      if @<%= orm_instance.save %>
+        format.html { redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully created.'" %> }
+        format.json { render json: <%= "@#{singular_table_name}" %>, status: :created }
+      else
+        format.html { render action: 'new' }
+        format.json { render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT <%= route_url %>/1
+  # PATCH/PUT <%= route_url %>/1.json
+  def update
+    respond_to do |format|
+      if @<%= orm_instance.update("#{singular_table_name}_params") %>
+        format.html { redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully updated.'" %> }
+        format.json { head :no_content }
+      else
+        format.html { render action: 'edit' }
+        format.json { render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE <%= route_url %>/1
+  # DELETE <%= route_url %>/1.json
+  def destroy
+    @<%= orm_instance.destroy %>
+    respond_to do |format|
+      format.html { redirect_to <%= index_helper %>_url }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_<%= singular_table_name %>
+      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def <%= "#{singular_table_name}_params" %>
+      <%- if attributes_names.empty? -%>
+      params[<%= ":#{singular_table_name}" %>]
+      <%- else -%>
+      params.require(<%= ":#{singular_table_name}" %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
+      <%- end -%>
+    end
+end
+<% end -%>

data/lib/active_model/serializer/railtie.rb

@@ -3,6 +3,7 @@ module ActiveModel
     initializer 'generators' do |app|
       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

data/lib/active_model/serializer/version.rb

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

data/lib/active_model_serializers.rb

@@ -1,10 +1,26 @@
 require 'active_support'
-require 'active_model/as_json_overrides'
+require 'active_record'
 require 'active_model/serializer'
 require 'active_model/serializer_support'
 require 'active_model/serializer/version'
-require 'active_model/serializer/railtie' if defined?(Rails)
+require 'active_model/serializer/railtie' if defined?(Rails) && defined?(Rails::Railtie)
 
+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/integration/active_record/active_record_test.rb

@@ -51,24 +51,24 @@ module ActiveModel
             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' }
+            'ar_sections' => [{ 'name' => 'ruby' }]
           }, post_serializer.as_json)
         end
       end
 
       private
 
-      def embed(klass, options = {})
-        old_assocs = Hash[ARPostSerializer._associations.to_a.map { |(name, association)| [name, association.dup] }]
+      def embed(serializer_class, options = {})
+        old_assocs = Hash[serializer_class._associations.to_a.map { |(name, association)| [name, association.dup] }]
 
-        ARPostSerializer._associations.each_value do |association|
+        serializer_class._associations.each_value do |association|
           association.embed = options[:embed]
           association.embed_in_root = options[:embed_in_root]
         end
 
         yield
       ensure
-        ARPostSerializer._associations = old_assocs
+        serializer_class._associations = old_assocs
       end
     end
   end

data/test/unit/active_model/serializer/has_many_test.rb

@@ -131,7 +131,7 @@ module ActiveModel
         }, @post_serializer.as_json)
       end
 
-      def test_associations_using_a_given_array_serializer
+      def test_associations_embedding_ids_using_a_given_array_serializer
         @association.embed = :ids
         @association.embed_in_root = true
         @association.serializer_class = Class.new(ActiveModel::ArraySerializer) do
@@ -145,6 +145,18 @@ module ActiveModel
           comments: { my_content: ['fake'] }
         }, @post_serializer.as_json)
       end
+
+      def test_associations_embedding_objects_using_a_given_array_serializer
+        @association.serializer_class = Class.new(ActiveModel::ArraySerializer) do
+          def serializable_object
+            { my_content: ['fake'] }
+          end
+        end
+
+        assert_equal({
+          'post' => { title: 'Title 1', body: 'Body 1', comments: { my_content: ['fake'] } }
+        }, @post_serializer.as_json)
+      end
     end
   end
 end

data/test/unit/active_model/serializer/has_one_test.rb

@@ -112,11 +112,11 @@ module ActiveModel
 
         assert_equal({
           'user' => { name: 'Name 1', email: 'mail@server.com', 'profile_id' => @user.profile.object_id },
-          profile: { name: 'N1', description: 'D1' }
+          'profiles' => [{ name: 'N1', description: 'D1' }]
         }, @user_serializer.as_json)
       end
 
-      def test_associations_using_a_given_serializer
+      def test_associations_embedding_ids_using_a_given_serializer
         @association.embed = :ids
         @association.embed_in_root = true
         @association.serializer_class = Class.new(ActiveModel::Serializer) do
@@ -129,7 +129,21 @@ module ActiveModel
 
         assert_equal({
           'user' => { name: 'Name 1', email: 'mail@server.com', 'profile_id' => @user.profile.object_id },
-          profile: { name: 'fake' }
+          'profiles' => [{ name: 'fake' }]
+        }, @user_serializer.as_json)
+      end
+
+      def test_associations_embedding_objects_using_a_given_serializer
+        @association.serializer_class = Class.new(ActiveModel::Serializer) do
+          def name
+            'fake'
+          end
+
+          attributes :name
+        end
+
+        assert_equal({
+          'user' => { name: 'Name 1', email: 'mail@server.com', profile: { name: 'fake' } }
         }, @user_serializer.as_json)
       end
     end

data/test/unit/active_model/serializer/scope_test.rb

@@ -17,5 +17,33 @@ module ActiveModel
         'user'
       end
     end
+
+    class NestedScopeTest < ActiveSupport::TestCase
+      def setup
+        @association = UserSerializer._associations[:profile]
+        @old_association = @association.dup
+        @user = User.new({ name: 'Name 1', email: 'mail@server.com', gender: 'M' })
+        @user_serializer = UserSerializer.new(@user, scope: 'user')
+      end
+
+      def teardown
+        UserSerializer._associations[:profile] = @old_association
+      end
+
+      def test_scope_passed_through
+        @association.serializer_class = Class.new(ActiveModel::Serializer) do
+          def name
+            scope
+          end
+
+          attributes :name
+        end
+
+        assert_equal({
+          name: 'Name 1', email: 'mail@server.com', profile: { name: 'user' }
+        }, @user_serializer.serializable_hash)
+      end
+    end
+
   end
 end

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_rails_2.3
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre1
+  version: 0.9.0.pre2
+  prerelease: 6
 platform: ruby
 authors:
 - José Valim
@@ -10,11 +11,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-04 00:00:00.000000000 Z
+date: 2013-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,6 +24,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -41,11 +44,12 @@ files:
 - DESIGN.textile
 - MIT-LICENSE
 - lib/active_model/array_serializer.rb
-- lib/active_model/as_json_overrides.rb
 - lib/active_model/default_serializer.rb
 - lib/active_model/serializable.rb
 - lib/active_model/serializer/associations.rb
 - lib/active_model/serializer/config.rb
+- lib/active_model/serializer/generators/serializer/scaffold_controller_generator.rb
+- lib/active_model/serializer/generators/serializer/templates/controller.rb
 - lib/active_model/serializer/railtie.rb
 - lib/active_model/serializer/version.rb
 - lib/active_model/serializer.rb
@@ -70,29 +74,29 @@ files:
 - test/unit/active_model/serializer/meta_test.rb
 - test/unit/active_model/serializer/root_test.rb
 - test/unit/active_model/serializer/scope_test.rb
-homepage: https://github.com/fivetanley/active_model_serializers_rails/tree/rails-2.3
-licenses:
-- MIT
-metadata: {}
+homepage: https://github.com/rails-api/active_model_serializers
+licenses: []
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>'
+  - - ! '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Bringing consistency and object orientation to model serialization. Works
   great for client-side MVC frameworks!
 test_files:
@@ -115,3 +119,4 @@ test_files:
 - test/unit/active_model/serializer/meta_test.rb
 - test/unit/active_model/serializer/root_test.rb
 - test/unit/active_model/serializer/scope_test.rb
+has_rdoc: 

checksums.yaml

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

data/lib/active_model/as_json_overrides.rb

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