active_model_serializers 0.8.4 → 0.9.0.alpha1

data/lib/active_model/serializer/associations.rb

@@ -1,231 +1,73 @@
+require 'active_model/default_serializer'
+require 'active_model/serializer'
+
 module ActiveModel
   class Serializer
-    module Associations #:nodoc:
-      class Config #:nodoc:
-        class_attribute :options
-
-        def self.refine(name, class_options)
-          current_class = self
-
-          Class.new(self) do
-            singleton_class.class_eval do
-              define_method(:to_s) do
-                "(subclass of #{current_class.name})"
-              end
-
-              alias inspect to_s
-            end
-
-            self.options = class_options
-
-            # cache the root so we can reuse it without falling back on a per-instance basis
-            begin
-              self.options[:root] ||= self.new(name, nil).root
-            rescue
-              # this could fail if it needs a valid source, for example a polymorphic association
-            end
-
-          end
-        end
-
-        self.options = {}
-
-        def initialize(name, source, options={})
-          @name = name
-          @source = source
-          @options = options
-        end
-
-        def option(key, default=nil)
-          if @options.key?(key)
-            @options[key]
-          elsif self.class.options.key?(key)
-            self.class.options[key]
-          else
-            default
-          end
-        end
-
-        def target_serializer
-          serializer = option(:serializer)
-          serializer.is_a?(String) ? serializer.constantize : serializer
-        end
-
-        def source_serializer
-          @source
-        end
-
-        def key
-          option(:key) || @name
-        end
-
-        def root
-          option(:root) || @name
-        end
-
-        def name
-          option(:name) || @name
-        end
-
-        def associated_object
-          option(:value) || source_serializer.send(name)
-        end
-
-        def embed_ids?
-          [:id, :ids].include? option(:embed, source_serializer._embed)
-        end
-
-        def embed_objects?
-          [:object, :objects].include? option(:embed, source_serializer._embed)
-        end
-
-        def embed_in_root?
-          option(:include, source_serializer._root_embed)
-        end
-
-        def embeddable?
-          !associated_object.nil?
-        end
-
-      protected
-
-        def find_serializable(object)
-          if target_serializer
-            target_serializer.new(object, source_serializer.options)
-          elsif object.respond_to?(:active_model_serializer) && (ams = object.active_model_serializer)
-            ams.new(object, source_serializer.options)
-          else
-            object
-          end
-        end
+    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_class = serializer.is_a?(String) ? serializer.constantize : serializer
       end
 
-      class HasMany < Config #:nodoc:
-        def key
-          if key = option(:key)
-            key
-          elsif embed_ids?
-            "#{@name.to_s.singularize}_ids".to_sym
-          else
-            @name
-          end
-        end
-
-        def embed_key
-          if key = option(:embed_key)
-            key
-          else
-            :id
-          end
-        end
-
-        def serialize
-          associated_object.map do |item|
-            find_serializable(item).serializable_hash
-          end
-        end
-
-        def serializables
-          associated_object.map do |item|
-            find_serializable(item)
-          end
-        end
+      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 serialize_ids
-          ids_key = "#{@name.to_s.singularize}_ids".to_sym
-          if !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(ids_key)
-            source_serializer.object.read_attribute_for_serialization(ids_key)
-          else
-            associated_object.map do |item|
-              item.read_attribute_for_serialization(embed_key)
-            end
-          end
-        end
+      def embed=(embed)
+        @embed_ids     = embed == :id || embed == :ids
+        @embed_objects = embed == :object || embed == :objects
       end
 
-      class HasOne < Config #:nodoc:
-        def embeddable?
-          if polymorphic? && associated_object.nil?
-            false
-          else
-            true
-          end
-        end
+      def build_serializer(object, options = {})
+        @serializer_class.new(object, options.merge(@options))
+      end
 
-        def polymorphic?
-          option :polymorphic
+      class HasOne < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s.pluralize
+          @key ||= "#{name}_id"
         end
 
-        def root
-          if root = option(:root)
-            root
-          elsif polymorphic?
-            associated_object.class.to_s.pluralize.demodulize.underscore.to_sym
-          else
-            @name.to_s.pluralize.to_sym
-          end
+        def build_serializer(object, options = {})
+          @serializer_class ||= Serializer.serializer_for(object) || DefaultSerializer
+          options[:_wrap_in_array] = embed_in_root?
+          super
         end
+      end
 
-        def key
-          if key = option(:key)
-            key
-          elsif embed_ids? && !polymorphic?
-            "#{@name}_id".to_sym
-          else
-            @name
-          end
+      class HasMany < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key
+          @key ||= "#{name.to_s.singularize}_ids"
         end
 
-        def embed_key
-          if key = option(:embed_key)
-            key
+        def build_serializer(object, options = {})
+          if @serializer_class && !(@serializer_class <= ArraySerializer)
+            @options[:each_serializer] = @serializer_class
+            @serializer_class = ArraySerializer
           else
-            :id
+            @serializer_class ||= ArraySerializer
           end
-        end
-
-        def polymorphic_key
-          associated_object.class.to_s.demodulize.underscore.to_sym
-        end
 
-        def serialize
-          object = associated_object
-
-          if object && polymorphic?
-            {
-              :type => polymorphic_key,
-              polymorphic_key => find_serializable(object).serializable_hash
-            }
-          elsif object
-            find_serializable(object).serializable_hash
-          end
-        end
-
-        def serializables
-          object = associated_object
-          value = object && find_serializable(object)
-          value ? [value] : []
-        end
-
-        def serialize_ids
-          id_key = "#{@name}_id".to_sym
-
-          if polymorphic?
-            if associated_object
-              {
-                :type => polymorphic_key,
-                :id => associated_object.read_attribute_for_serialization(embed_key)
-              }
-            else
-              nil
-            end
-          elsif !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(id_key)
-            source_serializer.object.read_attribute_for_serialization(id_key)
-          elsif associated_object
-            associated_object.read_attribute_for_serialization(embed_key)
-          else
-            nil
-          end
+          super
         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

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

@@ -0,0 +1,13 @@
+require 'rails/generators'
+require 'rails/generators/rails/resource/resource_generator'
+
+module Rails
+  module Generators
+    class ResourceGenerator
+      def add_serializer
+        invoke 'serializer'
+      end
+    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/serializer_generator.rb

@@ -0,0 +1,37 @@
+module Rails
+  module Generators
+    class SerializerGenerator < NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+      check_class_collision suffix: 'Serializer'
+
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+      class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
+
+      def create_serializer_file
+        template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+      end
+
+      private
+
+      def attributes_names
+        [:id] + attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def association_names
+        attributes.select { |attr| attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def parent_class_name
+        if options[:parent]
+          options[:parent]
+        elsif (ns = Rails::Generators.namespace) && ns.const_defined?(:ApplicationSerializer) ||
+               defined?(::ApplicationSerializer)
+          'ApplicationSerializer'
+        else
+          'ActiveModel::Serializer'
+        end
+      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 -%>