cheap_ams 0.10.0.rc2

data/lib/active_model/serializer/reflection.rb

@@ -0,0 +1,74 @@
+module ActiveModel
+  class Serializer
+    # Holds all the meta-data about an association as it was specified in the
+    # ActiveModel::Serializer class.
+    #
+    # @example
+    #  class PostSerializer < ActiveModel::Serializer
+    #     has_one :author, serializer: AuthorSerializer
+    #     has_many :comments
+    #  end
+    #
+    #  PostSerializer._reflections #=>
+    #    # [
+    #    #   HasOneReflection.new(:author, serializer: AuthorSerializer),
+    #    #   HasManyReflection.new(:comments)
+    #    # ]
+    #
+    # So you can inspect reflections in your Adapters.
+    #
+    Reflection = Struct.new(:name, :options) do
+      # Build association. This method is used internally to
+      # build serializer's association by its reflection.
+      #
+      # @param [Serializer] subject is a parent serializer for given association
+      # @param [Hash{Symbol => Object}] parent_serializer_options
+      #
+      # @example
+      #    # Given the following serializer defined:
+      #    class PostSerializer < ActiveModel::Serializer
+      #      has_many :comments, serializer: CommentSummarySerializer
+      #    end
+      #
+      #    # Then you instantiate your serializer
+      #    post_serializer = PostSerializer.new(post, foo: 'bar') #
+      #    # to build association for comments you need to get reflection
+      #    comments_reflection = PostSerializer._reflections.detect { |r| r.name == :comments }
+      #    # and #build_association
+      #    comments_reflection.build_association(post_serializer, foo: 'bar')
+      #
+      # @api private
+      #
+      def build_association(subject, parent_serializer_options)
+        association_value = subject.send(name)
+        reflection_options = options.dup
+        serializer_class = ActiveModel::Serializer.serializer_for(association_value, reflection_options)
+
+        if serializer_class
+          begin
+            serializer = serializer_class.new(
+              association_value,
+              serializer_options(parent_serializer_options, reflection_options)
+            )
+          rescue ActiveModel::Serializer::ArraySerializer::NoSerializerError
+            reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
+          end
+        elsif !association_value.nil? && !association_value.instance_of?(Object)
+          reflection_options[:virtual_value] = association_value
+        end
+
+        Association.new(name, serializer, reflection_options)
+      end
+
+      private
+
+      def serializer_options(parent_serializer_options, reflection_options)
+        serializer = reflection_options.fetch(:serializer, nil)
+
+        serializer_options = parent_serializer_options.except(:serializer)
+        serializer_options[:serializer] = serializer if serializer
+        serializer_options
+      end
+    end
+  end
+end

data/lib/active_model/serializer/singular_reflection.rb

@@ -0,0 +1,7 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class SingularReflection < Reflection
+    end
+  end
+end

data/lib/active_model/serializer/version.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  class Serializer
+    VERSION = "0.10.0.rc2"
+  end
+end

data/lib/active_model/serializer.rb

@@ -0,0 +1,205 @@
+require 'thread_safe'
+
+module ActiveModel
+  class Serializer
+    extend ActiveSupport::Autoload
+
+    autoload :Configuration
+    autoload :ArraySerializer
+    autoload :Adapter
+    autoload :Lint
+    autoload :Associations
+    autoload :Fieldset
+    include Configuration
+    include Associations
+
+
+    # Matches
+    #  "c:/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
+    #  AND
+    #  "/c/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
+    #  AS
+    #  c/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb
+    CALLER_FILE = /
+      \A       # start of string
+      \S+      # one or more non-spaces
+      (?=      # stop previous match when
+        :\d+     # a colon is followed by one or more digits
+        :in      # followed by a colon followed by in
+      )
+    /x
+
+    class << self
+      attr_accessor :_attributes
+      attr_accessor :_attributes_keys
+      attr_accessor :_urls
+      attr_accessor :_cache
+      attr_accessor :_fragmented
+      attr_accessor :_cache_key
+      attr_accessor :_cache_only
+      attr_accessor :_cache_except
+      attr_accessor :_cache_options
+      attr_accessor :_cache_digest
+    end
+
+    def self.inherited(base)
+      base._attributes = self._attributes.try(:dup) || []
+      base._attributes_keys = self._attributes_keys.try(:dup) || {}
+      base._urls = []
+      base._cache_digest = digest_caller_file(caller.first)
+      super
+    end
+
+    def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
+      @_attributes.concat attrs
+      @_attributes.uniq!
+
+      attrs.each do |attr|
+        define_method attr do
+          object && object.read_attribute_for_serialization(attr)
+        end unless method_defined?(attr) || _fragmented.respond_to?(attr)
+      end
+    end
+
+    def self.attribute(attr, options = {})
+      key = options.fetch(:key, attr)
+      @_attributes_keys[attr] = { key: key } if key != attr
+      @_attributes << key unless @_attributes.include?(key)
+
+      ActiveModelSerializers.silence_warnings do
+        define_method key do
+          object.read_attribute_for_serialization(attr)
+        end unless (key != :id && method_defined?(key)) || _fragmented.respond_to?(attr)
+      end
+    end
+
+    def self.fragmented(serializer)
+      @_fragmented = serializer
+    end
+
+    # Enables a serializer to be automatically cached
+    def self.cache(options = {})
+      @_cache = ActionController::Base.cache_store if Rails.configuration.action_controller.perform_caching
+      @_cache_key = options.delete(:key)
+      @_cache_only = options.delete(:only)
+      @_cache_except = options.delete(:except)
+      @_cache_options = (options.empty?) ? nil : options
+    end
+
+    def self.url(attr)
+      @_urls.push attr
+    end
+
+    def self.urls(*attrs)
+      @_urls.concat attrs
+    end
+
+    def self.serializer_for(resource, options = {})
+      if resource.respond_to?(:serializer_class)
+        resource.serializer_class
+      elsif resource.respond_to?(:to_ary)
+        config.array_serializer
+      else
+        options.fetch(:serializer, get_serializer_for(resource.class))
+      end
+    end
+
+    def self.adapter
+      adapter_class = case config.adapter
+                      when Symbol
+                        ActiveModel::Serializer::Adapter.adapter_class(config.adapter)
+                      when Class
+                        config.adapter
+                      end
+      unless adapter_class
+        valid_adapters = Adapter.constants.map { |klass| ":#{klass.to_s.downcase}" }
+        raise ArgumentError, "Unknown adapter: #{config.adapter}. Valid adapters are: #{valid_adapters}"
+      end
+
+      adapter_class
+    end
+
+    def self.root_name
+      name.demodulize.underscore.sub(/_serializer$/, '') if name
+    end
+
+    attr_accessor :object, :root, :meta, :meta_key, :scope
+
+    def initialize(object, options = {})
+      @object = object
+      @options = options
+      @root = options[:root]
+      @meta = options[:meta]
+      @meta_key = options[:meta_key]
+      @scope = options[:scope]
+
+      scope_name = options[:scope_name]
+      if scope_name && !respond_to?(scope_name)
+        self.class.class_eval do
+          define_method scope_name, lambda { scope }
+        end
+      end
+    end
+
+    def json_key
+      @root || object.class.model_name.to_s.underscore
+    end
+
+    def id
+      object.id if object
+    end
+
+    def json_api_type
+      if config.jsonapi_resource_type == :plural
+        object.class.model_name.plural
+      else
+        object.class.model_name.singular
+      end
+    end
+
+    def attributes(options = {})
+      attributes =
+        if options[:fields]
+          self.class._attributes & options[:fields]
+        else
+          self.class._attributes.dup
+        end
+
+      attributes += options[:required_fields] if options[:required_fields]
+
+      attributes.each_with_object({}) do |name, hash|
+        unless self.class._fragmented
+          hash[name] = send(name)
+        else
+          hash[name] = self.class._fragmented.public_send(name)
+        end
+      end
+    end
+
+    def self.serializers_cache
+      @serializers_cache ||= ThreadSafe::Cache.new
+    end
+
+    def self.digest_caller_file(caller_line)
+      serializer_file_path = caller_line[CALLER_FILE]
+      serializer_file_contents = IO.read(serializer_file_path)
+      Digest::MD5.hexdigest(serializer_file_contents)
+    end
+
+    attr_reader :options
+
+    def self.get_serializer_for(klass)
+      serializers_cache.fetch_or_store(klass) do
+        serializer_class_name = "#{klass.name}Serializer"
+        serializer_class = serializer_class_name.safe_constantize
+
+        if serializer_class
+          serializer_class
+        elsif klass.superclass
+          get_serializer_for(klass.superclass)
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers.rb

@@ -0,0 +1,29 @@
+module ActiveModelSerializers
+  module_function
+
+  def silence_warnings
+    verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = verbose
+  end
+
+end
+
+require 'active_model'
+require 'action_controller'
+
+require 'active_model/serializer'
+require 'active_model/serializable_resource'
+require 'active_model/serializer/version'
+
+require 'action_controller/serialization'
+ActiveSupport.on_load(:action_controller) do
+  include ::ActionController::Serialization
+  ActionDispatch::Reloader.to_prepare do
+    ActiveModel::Serializer.serializers_cache.clear
+  end
+end
+
+require 'active_model/serializer/railtie'

data/lib/generators/serializer/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Generates a serializer for the given resource with tests.
+
+Example:
+    `rails generate serializer Account name created_at`
+

data/lib/generators/serializer/resource_override.rb

@@ -0,0 +1,12 @@
+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/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 defined?(::ApplicationSerializer)
+          "ApplicationSerializer"
+        else
+          "ActiveModel::Serializer"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,8 @@
+<% module_namespacing do -%>
+class <%= class_name %>Serializer < <%= parent_class_name %>
+  attributes <%= attributes_names.map(&:inspect).join(", ") %>
+<% association_names.each do |attribute| -%>
+  has_one :<%= attribute %>
+<% end -%>
+end
+<% end -%>

data/test/action_controller/adapter_selector_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class AdapterSelectorTest < ActionController::TestCase
+      class AdapterSelectorTestController < ActionController::Base
+        def render_using_default_adapter
+          @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+          render json: @profile
+        end
+
+        def render_using_adapter_override
+          @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+          render json: @profile, adapter: :json_api
+        end
+
+        def render_skipping_adapter
+          @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+          render json: @profile, adapter: false
+        end
+      end
+
+      tests AdapterSelectorTestController
+
+      def test_render_using_default_adapter
+        get :render_using_default_adapter
+        assert_equal '{"name":"Name 1","description":"Description 1"}', response.body
+      end
+
+      def test_render_using_adapter_override
+        get :render_using_adapter_override
+
+        expected = {
+          data: {
+            id: assigns(:profile).id.to_s,
+            type: "profiles",
+            attributes: {
+              name: "Name 1",
+              description: "Description 1",
+            }
+          }
+        }
+
+        assert_equal expected.to_json, response.body
+      end
+
+      def test_render_skipping_adapter
+        get :render_skipping_adapter
+        assert_equal '{"attributes":{"name":"Name 1","description":"Description 1","comments":"Comments 1"}}', response.body
+      end
+    end
+  end
+end

data/test/action_controller/explicit_serializer_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class ExplicitSerializerTest < ActionController::TestCase
+      class ExplicitSerializerTestController < ActionController::Base
+        def render_using_explicit_serializer
+          @profile = Profile.new(name: 'Name 1',
+                                 description: 'Description 1',
+                                 comments: 'Comments 1')
+          render json: @profile, serializer: ProfilePreviewSerializer
+        end
+
+        def render_array_using_explicit_serializer
+          array = [
+            Profile.new(name: 'Name 1',
+                        description: 'Description 1',
+                        comments: 'Comments 1'),
+            Profile.new(name: 'Name 2',
+                        description: 'Description 2',
+                        comments: 'Comments 2')
+          ]
+          render json: array,
+                 serializer: PaginatedSerializer,
+                 each_serializer: ProfilePreviewSerializer
+        end
+
+        def render_array_using_implicit_serializer
+          array = [
+            Profile.new(name: 'Name 1',
+                        description: 'Description 1',
+                        comments: 'Comments 1'),
+            Profile.new(name: 'Name 2',
+                        description: 'Description 2',
+                        comments: 'Comments 2')
+          ]
+          render json: array,
+                 each_serializer: ProfilePreviewSerializer
+        end
+
+        def render_array_using_explicit_serializer_and_custom_serializers
+          @post = Post.new(title: 'New Post', body: 'Body')
+          @author = Author.new(name: 'Jane Blogger')
+          @author.posts = [@post]
+          @post.author = @author
+          @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+          @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
+          @post.comments = [@first_comment, @second_comment]
+          @first_comment.post = @post
+          @first_comment.author = nil
+          @second_comment.post = @post
+          @second_comment.author = nil
+          @blog = Blog.new(id: 23, name: 'AMS Blog')
+          @post.blog = @blog
+
+          render json: [@post], each_serializer: PostPreviewSerializer
+        end
+
+        def render_using_explicit_each_serializer
+          location       = Location.new(id: 42, lat: '-23.550520', lng: '-46.633309')
+          place          = Place.new(id: 1337, name: 'Amazing Place', locations: [location])
+
+          render json: place, each_serializer: PlaceSerializer
+        end
+      end
+
+      tests ExplicitSerializerTestController
+
+      def test_render_using_explicit_serializer
+        get :render_using_explicit_serializer
+
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"name":"Name 1"}', @response.body
+      end
+
+      def test_render_array_using_explicit_serializer
+        get :render_array_using_explicit_serializer
+        assert_equal 'application/json', @response.content_type
+
+        expected = [
+          { 'name' => 'Name 1' },
+          { 'name' => 'Name 2' }
+        ]
+
+        assert_equal expected.to_json, @response.body
+      end
+
+      def test_render_array_using_implicit_serializer
+        get :render_array_using_implicit_serializer
+        assert_equal 'application/json', @response.content_type
+
+        expected = [
+          { 'name' => 'Name 1' },
+          { 'name' => 'Name 2' }
+        ]
+        assert_equal expected.to_json, @response.body
+      end
+
+      def test_render_array_using_explicit_serializer_and_custom_serializers
+        get :render_array_using_explicit_serializer_and_custom_serializers
+
+        expected = [
+          { "title" => "New Post",
+            "body" => "Body",
+            "id" => assigns(:post).id,
+            "comments" => [{"id" => 1}, {"id" => 2}],
+            "author" => { "id" => assigns(:author).id }
+          }
+        ]
+
+        assert_equal expected.to_json, @response.body
+      end
+
+      def test_render_using_explicit_each_serializer
+        get :render_using_explicit_each_serializer
+
+        expected = {
+          id: 1337,
+          name: "Amazing Place",
+          locations: [
+            {
+              id: 42,
+              lat: "-23.550520",
+              lng: "-46.633309",
+              place: "Nowhere" # is a virtual attribute on LocationSerializer
+            }
+          ]
+        }
+
+        assert_equal expected.to_json, response.body
+      end
+    end
+  end
+end