cm-active_model_serializers 0.10.0.rc1.1

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts = ['-r./test/test_helper.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/cm-active_model_serializers.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_model/serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cm-active_model_serializers"
+  spec.version       = ActiveModel::Serializer::VERSION
+  spec.authors       = ["Steve Klabnik"]
+  spec.email         = ["steve@steveklabnik.com"]
+  spec.summary       = %q{Conventions-based JSON generation for Rails.}
+  spec.description   = %q{ActiveModel::Serializers allows you to generate your JSON in an object-oriented and convention-driven manner.}
+  spec.homepage      = "https://github.com/rails-api/active_model_serializers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel", ">= 4.0"
+
+  spec.add_development_dependency "rails", ">= 4.0"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/action_controller/serialization.rb

@@ -0,0 +1,62 @@
+require 'active_support/core_ext/class/attribute'
+
+module ActionController
+  module Serialization
+    extend ActiveSupport::Concern
+
+    include ActionController::Renderers
+
+    ADAPTER_OPTION_KEYS = [:include, :fields, :root, :adapter]
+
+    included do
+      class_attribute :_serialization_scope
+      self._serialization_scope = :current_user
+    end
+
+    def serialization_scope
+      send(_serialization_scope) if _serialization_scope &&
+        respond_to?(_serialization_scope, true)
+    end
+
+    def get_serializer(resource)
+      @_serializer ||= @_serializer_opts.delete(:serializer)
+      @_serializer ||= ActiveModel::Serializer.serializer_for(resource)
+
+      if @_serializer_opts.key?(:each_serializer)
+        @_serializer_opts[:serializer] = @_serializer_opts.delete(:each_serializer)
+      end
+
+      @_serializer
+    end
+
+    def use_adapter?
+      !(@_adapter_opts.key?(:adapter) && !@_adapter_opts[:adapter])
+    end
+
+    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
+      define_method renderer_method do |resource, options|
+        @_adapter_opts, @_serializer_opts =
+          options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }.map { |h| Hash[h] }
+
+        if use_adapter? && (serializer = get_serializer(resource))
+
+          @_serializer_opts[:scope] ||= serialization_scope
+          @_serializer_opts[:scope_name] = _serialization_scope
+
+          # omg hax
+          object = serializer.new(resource, @_serializer_opts)
+          adapter = ActiveModel::Serializer::Adapter.create(object, @_adapter_opts)
+          super(adapter, options)
+        else
+          super(resource, options)
+        end
+      end
+    end
+
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
+      end
+    end
+  end
+end

data/lib/active_model/serializer.rb

@@ -0,0 +1,261 @@
+require 'thread_safe'
+
+module ActiveModel
+  class Serializer
+    extend ActiveSupport::Autoload
+    autoload :Configuration
+    autoload :ArraySerializer
+    autoload :Adapter
+    include Configuration
+
+    class << self
+      attr_accessor :_attributes
+      attr_accessor :_attributes_keys
+      attr_accessor :_associations
+      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
+    end
+
+    def self.inherited(base)
+      base._attributes = self._attributes.try(:dup)  || []
+      base._attributes_keys = self._attributes_keys.try(:dup) || {}
+      base._associations = self._associations.try(:dup) || {}
+      base._urls = []
+    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)
+      define_method key do
+        object.read_attribute_for_serialization(attr)
+      end unless method_defined?(key) || _fragmented.respond_to?(attr)
+    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
+
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an array when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    def self.has_many(*attrs)
+      associate(:has_many, attrs)
+    end
+
+    # Defines an association in the object that should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an object when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    def self.belongs_to(*attrs)
+      associate(:belongs_to, attrs)
+    end
+
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an object when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    def self.has_one(*attrs)
+      associate(:has_one, attrs)
+    end
+
+    def self.associate(type, attrs) #:nodoc:
+      options = attrs.extract_options!
+      self._associations = _associations.dup
+
+      attrs.each do |attr|
+        unless method_defined?(attr)
+          define_method attr do
+            object.send attr
+          end
+        end
+
+        self._associations[attr] = {type: type, association_options: options}
+      end
+    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(:association_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
+      @@root ||= false
+    end
+
+    def self._root=(root)
+      @@root = root
+    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] || (self.class._root ? self.class.root_name : false)
+      @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
+      if root == true || root.nil?
+        self.class.root_name
+      else
+        root
+      end
+    end
+
+    def id
+      object.id if object
+    end
+
+    def type
+      object.class.to_s.demodulize.underscore.pluralize
+    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 each_association(&block)
+      self.class._associations.dup.each do |name, association_options|
+        next unless object
+        association_value = send(name)
+
+        serializer_class = ActiveModel::Serializer.serializer_for(association_value, association_options)
+
+        if serializer_class
+          serializer = serializer_class.new(
+            association_value,
+            options.merge(serializer_from_options(association_options))
+          )
+        elsif !association_value.nil? && !association_value.instance_of?(Object)
+          association_options[:association_options][:virtual_value] = association_value
+        end
+
+        if block_given?
+          block.call(name, serializer, association_options[:association_options])
+        end
+      end
+    end
+
+    def serializer_from_options(options)
+      opts = {}
+      serializer = options.fetch(:association_options, {}).fetch(:serializer, nil)
+      opts[:serializer] = serializer if serializer
+      opts
+    end
+
+    def self.serializers_cache
+      @serializers_cache ||= ThreadSafe::Cache.new
+    end
+
+    private
+
+    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/serializer/adapter.rb

@@ -0,0 +1,87 @@
+require 'active_model/serializer/adapter/fragment_cache'
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      extend ActiveSupport::Autoload
+      autoload :Json
+      autoload :Null
+      autoload :JsonApi
+
+      attr_reader :serializer
+
+      def initialize(serializer, options = {})
+        @serializer = serializer
+        @options = options
+      end
+
+      def serializable_hash(options = {})
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
+      def as_json(options = {})
+        hash = serializable_hash(options)
+        include_meta(hash)
+      end
+
+      def self.create(resource, options = {})
+        override = options.delete(:adapter)
+        klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
+        klass.new(resource, options)
+      end
+
+      def self.adapter_class(adapter)
+        "ActiveModel::Serializer::Adapter::#{adapter.to_s.classify}".safe_constantize
+      end
+
+      def fragment_cache(*args)
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
+      private
+
+     def cache_check(serializer)
+        @cached_serializer = serializer
+        @klass             = @cached_serializer.class
+        if is_cached?
+          @klass._cache.fetch(cache_key, @klass._cache_options) do
+            yield
+          end
+        elsif is_fragment_cached?
+          FragmentCache.new(self, @cached_serializer, @options, @root).fetch
+        else
+          yield
+        end
+      end
+
+      def is_cached?
+        @klass._cache && !@klass._cache_only && !@klass._cache_except
+      end
+
+      def is_fragment_cached?
+        @klass._cache_only && !@klass._cache_except || !@klass._cache_only && @klass._cache_except
+      end
+
+      def cache_key
+        (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{@cached_serializer.object.updated_at}" : @cached_serializer.object.cache_key
+      end
+
+      def meta
+        serializer.meta if serializer.respond_to?(:meta)
+      end
+
+      def meta_key
+        serializer.meta_key || "meta"
+      end
+
+      def root
+        serializer.json_key
+      end
+
+      def include_meta(json)
+        json[meta_key] = meta if meta && root
+        json
+      end
+    end
+  end
+end