active_model_serializers_rails_2.3 0.9.0.alpha1

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

@@ -0,0 +1,10 @@
+module ActiveModel
+  class Railtie < Rails::Railtie
+    initializer 'generators' do |app|
+      app.load_generators
+      require 'active_model/serializer/generators/serializer/serializer_generator'
+      require 'active_model/serializer/generators/serializer/scaffold_controller_generator'
+      require 'active_model/serializer/generators/resource_override'
+    end
+  end
+end

data/lib/active_model/serializer/version.rb

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

data/lib/active_model/serializer_support.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  module SerializerSupport
+    alias read_attribute_for_serialization send
+  end
+end

data/lib/active_model_serializers.rb

@@ -0,0 +1,33 @@
+require 'active_support'
+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) && 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'
+
+  ActiveSupport.on_load(:action_controller) do
+    include ::ActionController::Serialization
+  end
+rescue LoadError
+  # rails not installed, continuing
+end

data/test/coverage_setup.rb

@@ -0,0 +1,15 @@
+begin
+  require 'simplecov'
+  require 'coveralls'
+
+  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
+end

data/test/fixtures/active_record.rb

@@ -0,0 +1,92 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Schema.define do
+  create_table :ar_posts, force: true do |t|
+    t.string     :title
+    t.text       :body
+    t.belongs_to :ar_section, index: true
+    t.timestamps
+  end
+
+  create_table :ar_comments, force: true do |t|
+    t.text       :body
+    t.belongs_to :ar_post, index: true
+    t.timestamps
+  end
+
+  create_table :ar_tags, force: true do |t|
+    t.string :name
+  end
+
+  create_table :ar_sections, force: true do |t|
+    t.string :name
+  end
+
+  create_table :ar_posts_tags, force: true, id: false do |t|
+    t.references :ar_post, :ar_tag, index: true
+  end
+
+  create_table :ar_comments_tags, force: true, id: false do |t|
+    t.references :ar_comment, :ar_tag, index: true
+  end
+end
+
+class ARPost < ActiveRecord::Base
+  has_many :ar_comments, class_name: 'ARComment'
+  has_and_belongs_to_many :ar_tags, class_name: 'ARTag', join_table: :ar_posts_tags
+  belongs_to :ar_section, class_name: 'ARSection'
+end
+
+class ARComment < ActiveRecord::Base
+  belongs_to :ar_post, class_name: 'ARPost'
+  has_and_belongs_to_many :ar_tags, class_name: 'ARTag', join_table: :ar_comments_tags
+end
+
+class ARTag < ActiveRecord::Base
+end
+
+class ARSection < ActiveRecord::Base
+end
+
+class ARPostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :ar_comments, :ar_tags
+  has_one  :ar_section
+end
+
+class ARCommentSerializer < ActiveModel::Serializer
+  attributes :body
+
+  has_many :ar_tags
+end
+
+class ARTagSerializer < ActiveModel::Serializer
+  attributes :name
+end
+
+class ARSectionSerializer < ActiveModel::Serializer
+  attributes 'name'
+end
+
+ARPost.create(title: 'New post',
+              body:  'A body!!!',
+              ar_section: ARSection.create(name: 'ruby')).tap do |post|
+
+  short_tag = post.ar_tags.create(name: 'short')
+  whiny_tag = post.ar_tags.create(name: 'whiny')
+  happy_tag = ARTag.create(name: 'happy')
+
+  post.ar_comments.create(body: 'what a dumb post').tap do |comment|
+    comment.ar_tags.concat happy_tag, whiny_tag
+  end
+
+  post.ar_comments.create(body: 'i liked it').tap do |comment|
+    comment.ar_tags.concat happy_tag, short_tag
+  end
+end

data/test/fixtures/poro.rb

@@ -0,0 +1,64 @@
+class Model
+  def initialize(hash={})
+    @attributes = hash
+  end
+
+  def read_attribute_for_serialization(name)
+    if name == :id || name == 'id'
+      object_id
+    else
+      @attributes[name]
+    end
+  end
+end
+
+
+###
+## Models
+###
+class User < Model
+  def profile
+    @profile ||= Profile.new(name: 'N1', description: 'D1')
+  end
+end
+
+class Profile < Model
+end
+
+class Post < Model
+  def comments
+    @comments ||= [Comment.new(content: 'C1'),
+                   Comment.new(content: 'C2')]
+  end
+end
+
+class Comment < Model
+end
+
+###
+## Serializers
+###
+class UserSerializer < ActiveModel::Serializer
+  attributes :name, :email
+
+  has_one :profile
+end
+
+class ProfileSerializer < ActiveModel::Serializer
+  def description
+    description = object.read_attribute_for_serialization(:description)
+    scope ? "#{description} - #{scope}" : description
+  end
+
+  attributes :name, :description
+end
+
+class PostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :comments
+end
+
+class CommentSerializer < ActiveModel::Serializer
+  attributes :content
+end

data/test/integration/active_record/active_record_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+require 'fixtures/active_record'
+
+module ActiveModel
+  class Serializer
+    class ActiveRecordTest < Minitest::Test
+      def setup
+        @post = ARPost.first
+      end
+
+      def test_serialization_embedding_objects
+        post_serializer = ARPostSerializer.new(@post)
+
+        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_section: { 'name' => 'ruby' }
+          }
+        }, post_serializer.as_json)
+      end
+
+      def test_serialization_embedding_ids
+        post_serializer = ARPostSerializer.new(@post)
+
+        embed(ARPostSerializer, embed: :ids) 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
+            }
+          }, post_serializer.as_json)
+        end
+      end
+
+      def test_serialization_embedding_ids_including_in_root
+        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
+        end
+      end
+
+      private
+
+      def embed(serializer_class, options = {})
+        old_assocs = Hash[serializer_class._associations.to_a.map { |(name, association)| [name, association.dup] }]
+
+        serializer_class._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
+      end
+    end
+  end
+end

data/test/test_app.rb

@@ -0,0 +1,11 @@
+class TestApp < Rails::Application
+  if Rails.version.to_s.first >= '4'
+    config.eager_load = false
+    config.secret_key_base = 'abc123'
+  end
+
+  # Set up a logger to avoid creating a log directory on every run.
+  config.logger = Logger.new(nil)
+end
+
+TestApp.initialize!

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require 'bundler/setup'
+require 'coverage_setup'
+require 'minitest/autorun'
+require 'active_model_serializers'
+require 'fixtures/poro'
+require 'fixtures/active_record'
+
+# Ensure backward compatibility with Minitest 4
+Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
+
+module TestHelper
+end
+