adequate_serialization 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 344b36d7176362ee9a050bff405cd6a71d56971d6f6fe9f2dce5ed48a4aa9616
+  data.tar.gz: 79cacfe1d48763618a46d1ef342f49ae96b0c239589ee593260aad0f65acb781
+SHA512:
+  metadata.gz: 4bdb02b1d09a567d965857bd152f3846614f7b7ff2080431aa0c3360940009d4a459e68576d295ba9af8fae452be48bd2ad0fb8a3610d54543ec701177792e9a
+  data.tar.gz: 149976b0d5f6bf2eafa3742ea3f7bc0ad4315b6a759da1d320a29e739ca7cae334e79a492a2415e459c21e52f94900d41649cf8db602bd1eb6a5ce6890d9e2ae

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,7 @@
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  TargetRubyVersion: 2.5
+
+Style/Documentation:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm: 2.5.1
+cache: bundler
+branches:
+  only:
+  - master
+before_install:
+- gem update --system
+- gem install bundler
+script:
+- bundle exec rake
+- bundle exec rubocop --parallel

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rails', '~> 5', '>= 5.2'
+gem 'sqlite3'

data/Gemfile.lock

@@ -0,0 +1,154 @@
+PATH
+  remote: .
+  specs:
+    adequate_serialization (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (5.2.0)
+      actionpack (= 5.2.0)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailer (5.2.0)
+      actionpack (= 5.2.0)
+      actionview (= 5.2.0)
+      activejob (= 5.2.0)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (5.2.0)
+      actionview (= 5.2.0)
+      activesupport (= 5.2.0)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.0)
+      activesupport (= 5.2.0)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activejob (5.2.0)
+      activesupport (= 5.2.0)
+      globalid (>= 0.3.6)
+    activemodel (5.2.0)
+      activesupport (= 5.2.0)
+    activerecord (5.2.0)
+      activemodel (= 5.2.0)
+      activesupport (= 5.2.0)
+      arel (>= 9.0)
+    activestorage (5.2.0)
+      actionpack (= 5.2.0)
+      activerecord (= 5.2.0)
+      marcel (~> 0.3.1)
+    activesupport (5.2.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    ast (2.4.0)
+    builder (3.2.3)
+    concurrent-ruby (1.0.5)
+    crass (1.0.4)
+    docile (1.3.0)
+    erubi (1.7.1)
+    globalid (0.4.1)
+      activesupport (>= 4.2.0)
+    i18n (1.0.1)
+      concurrent-ruby (~> 1.0)
+    json (2.1.0)
+    loofah (2.2.2)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.0)
+      mini_mime (>= 0.1.1)
+    marcel (0.3.2)
+      mimemagic (~> 0.3.2)
+    method_source (0.9.0)
+    mimemagic (0.3.2)
+    mini_mime (1.0.0)
+    mini_portile2 (2.3.0)
+    minitest (5.11.3)
+    nio4r (2.3.1)
+    nokogiri (1.8.2)
+      mini_portile2 (~> 2.3.0)
+    parallel (1.12.1)
+    parser (2.5.1.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.1)
+    rack (2.0.5)
+    rack-test (1.0.0)
+      rack (>= 1.0, < 3)
+    rails (5.2.0)
+      actioncable (= 5.2.0)
+      actionmailer (= 5.2.0)
+      actionpack (= 5.2.0)
+      actionview (= 5.2.0)
+      activejob (= 5.2.0)
+      activemodel (= 5.2.0)
+      activerecord (= 5.2.0)
+      activestorage (= 5.2.0)
+      activesupport (= 5.2.0)
+      bundler (>= 1.3.0)
+      railties (= 5.2.0)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (5.2.0)
+      actionpack (= 5.2.0)
+      activesupport (= 5.2.0)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rainbow (3.0.0)
+    rake (12.3.1)
+    rubocop (0.56.0)
+      parallel (~> 1.10)
+      parser (>= 2.5)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.9.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    sprockets (3.7.1)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.1)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    sqlite3 (1.3.13)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.3.2)
+    websocket-driver (0.7.0)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  adequate_serialization!
+  bundler (~> 1)
+  minitest (~> 5)
+  rails (~> 5, >= 5.2)
+  rake (~> 12)
+  rubocop (~> 0.52)
+  simplecov (~> 0.16)
+  sqlite3
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Kevin Deisz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# AdequateSerialization
+
+[![Build Status](https://travis-ci.org/kddeisz/adequate_serialization.svg?branch=master)](https://travis-ci.org/kddeisz/adequate_serialization)
+
+Serializes objects adequately. `AdequateSerialization` allows you to define serializers that will convert your objects into simple hashes that are suitable for variable purposes such as caching or using in an HTTP response. It stems from the simple idea of giving slightly more control over the `as_json` method that gets called when objects are serialized using Rails' default controller serialization.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'adequate_serialization'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install adequate_serialization
+
+## Usage
+
+First, include `AdequateSerialization::Serializable` in any object that you want to be able to serialize. Then, define a serializer matching the name of that object, postfixed with `"Serializer"`. Use the `AdequateSerialization` DSL to define the attributes that are available to the serializer. You can then call `as_json` on any instance of that object to get the resultant hash. Below is an example:
+
+```ruby
+class User
+  include AdequateSerialization::Serializable
+
+  attr_reader :id, :name, :title
+
+  ...
+end
+
+class UserSerializer < AdequateSerialization::Serializer
+  attribute :id, :name, :title
+end
+
+User.new(id: 1, name: 'Clark Kent', title: 'Superman').as_json
+# => {:id=>1, :name=>"Clark Kent", :title=>"Superman"}
+```
+
+### Defining attributes
+
+The `AdequateSerialization::Serializer` DSL is just the one `attribute` method. You can pass as many names as you want, and each attribute will become a key in the resultant serialized hash. If you need to build a "synthesized" attribute (one that is defined in the serializer), you can do so with a block that receives the object as an argument, as in:
+
+```ruby
+class UserSerializer < AdequateSerialization::Serializer
+  attribute :double_name do |user|
+    user.name * 2
+  end
+end
+```
+
+There are also a couple of options that you can pass to the `attribute` method as the last argument that modify the serializer's behavior, listed below.
+
+#### :if
+
+If you pass an `:if` condition, that method will be called on the serializable object to determine whether or not that attribute should be included in the resultant hash, as in:
+
+```ruby
+class UserSerializer < AdequateSerialization::Serializer
+  attribute :title, if: :manager?
+end
+
+user = User.new(...)
+user.as_json
+# => {:id=>1, :name=>"Clark Kent"}
+
+user.update(manager: true)
+user.as_json
+# => {:id=>1, :name=>"Clark Kent", :title=>"Superman"}
+```
+
+#### :unless
+
+This is the same as the `:if` option, but will result in the opposite behavior (the attribute will be present if the predicate is not met).
+
+#### :optional
+
+There are times when you want to include an attribute that you normally wouldn't. For example, if you have both `Post` and `Comment` objects, normally you wouldn't include the `post` attribute on the child `comment` objects. However, if you're serializing just the comment, it might be useful to have the `post` attached. In this case, you could mark the attribute as `optional` and it would only be included if it was listed in the `:includes` option passed to the `as_json` method, as in:
+
+```ruby
+class PostSerializer < AdequateSerialization::Serializer
+  attribute :id, :title, :body
+  attribute :comments, optional: true
+end
+
+class CommentSerializer < AdequateSerialization::Serializer
+  attribute :id, :body
+  attribute :post, optional: true
+end
+
+comment = Comment.new(...)
+comment.as_json
+# => {:id=>1, :body=>"This is a great gem!"}
+
+comment.as_json(includes: :post)
+# => {:id=>1, :body=>"This is a great gem!", :post=>{:id=>1, :title=>"Introducing Adequate Serializer", :body=>"This is adequate serializer."}}
+```
+
+The `includes` key can take either a single name or an array of names.
+
+### Attaching objects
+
+There are times where it's more performant to serialize the objects using normal serialization and to attach an additional attribute later. For instance, you could serialize all of the posts and then attach whether or not a user had upvoted them. In that case, there's a special syntax that looks like the below:
+
+```ruby
+upvotes =
+  User.upvotes.each_with_object({}) do |post, votes|
+    votes[post.id] = true
+  end
+# => {1=>true}
+
+Post.all.map(&:as_json)
+# => [{:id=>1}, {:id=>2}]
+
+posts = Post.all.map { |post| post.as_json(attach: { upvoted: upvotes }) }
+# => [{:id=>1, :upvoted=>true}, {:id=>2, :upvoted=>false}]
+```
+
+This relies on the objects to which you are attaching having an `id` attribute and the attachable hash being an index of `id` pointing to the attribute value.
+
+### Usage with Rails
+
+To get `AdequateSerializer` working with Rails, you can call `AdequateSerializion.hook_into_rails!` in an initializer. This will do three things:
+
+1. Introduce caching behavior so that when serializing objects they will by default be stored in the Rails cache.
+1. Include `AdequateSerializer::Serializable` in `ActiveRecord::Base` so that all of your models will be serializable.
+2. Overwrite `ActiveRecord::Relation`'s `as_json` method to use the `AdequateSerializer::Rails::RelationSerializer` object, which by default will use the `Rails.cache.fetch_multi` method in order to more efficiently serialize all of the records in the relation.
+
+You can still use plain objects to be serialized, and if you want to take advantage of the caching behavior, you can define a `cache_key` method on the objects that you're serializing. This will cause `AdequateSerialization` to start putting them into the Rails cache.
+
+The result is that you can now this in your controllers:
+
+```ruby
+class UsersController
+  def show
+    user = User.find(params[:id])
+
+    render json: { user: user }
+  end
+end
+```
+
+and the response will be the serialized user. You can pass additional options that will get forwarded on to the serializer as well, as in:
+
+```ruby
+class UsersController
+  def show
+    user = User.find(params[:id])
+
+    render json: { user: user }, includes: :title
+  end
+end
+```
+
+and the result will now contain the `title` attribute (provided it was configured as an optional attribute). All options that previously were passed in to the `as_json` method get forwarded appropriately.
+
+### Advanced
+
+The serialization process happens through a series of `AdequateSerialization::Steps`. The caching behavior mentioned in the `Usage with Rails` section is one such step that gets introduced. You can introduce more yourself like so:
+
+```ruby
+class LoggingStep < AdequateSerialization::Steps::PassthroughStep
+  def apply(response)
+    Logger.log("#{response.object} is being serialized with #{response.opts} options")
+    apply_next(response)
+  end
+end
+
+AdequateSerialization.prepend(LoggingStep)
+```
+
+This will cause this object to be placed into the list of steps taken to serialize objects, and can be used for much more powerful and advanced workflows.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kddeisz/adequate_serialization.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/adequate_serialization.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'adequate_serialization/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'adequate_serialization'
+  spec.version       = AdequateSerialization::VERSION
+  spec.authors       = ['Kevin Deisz']
+  spec.email         = ['kevin.deisz@gmail.com']
+
+  spec.summary       = 'Serializes objects adequately'
+  spec.homepage      = 'https://github.com/kddeisz/adequate_serialization'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'rake', '~> 12'
+  spec.add_development_dependency 'rubocop', '~> 0.52'
+  spec.add_development_dependency 'simplecov', '~> 0.16'
+end

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'adequate_serialization'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/adequate_serialization.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'adequate_serialization/attribute'
+require 'adequate_serialization/decorator'
+require 'adequate_serialization/options'
+require 'adequate_serialization/serializable'
+require 'adequate_serialization/serializer'
+require 'adequate_serialization/steps'
+require 'adequate_serialization/version'
+
+require 'adequate_serialization/steps/passthrough_step'
+require 'adequate_serialization/steps/serialize_step'
+
+module AdequateSerialization
+  class << self
+    def dump(object)
+      if object.is_a?(Hash)
+        object
+      elsif object.respond_to?(:as_json)
+        object.as_json
+      else
+        object
+      end
+    end
+
+    def hook_into_rails!
+      @hook_into_rails ||=
+        begin
+          require 'adequate_serialization/rails/hook'
+          Rails.hook_in!
+        end
+    end
+  end
+end

data/lib/adequate_serialization/attribute.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Attribute
+    class Simple
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def serialize_to(response, model, _includes)
+        response[name] = AdequateSerialization.dump(model.public_send(name))
+      end
+    end
+
+    class Synthesized
+      attr_reader :name, :block
+
+      def initialize(name, &block)
+        @name = name
+        @block = block
+      end
+
+      def serialize_to(response, model, _includes)
+        response[name] = AdequateSerialization.dump(block.call(model))
+      end
+    end
+
+    class IfCondition
+      attr_reader :attribute, :condition
+
+      def initialize(attribute, condition)
+        @attribute = attribute
+        @condition = condition
+      end
+
+      def serialize_to(response, model, includes)
+        return unless model.public_send(condition)
+        attribute.serialize_to(response, model, includes)
+      end
+    end
+
+    class UnlessCondition
+      attr_reader :attribute, :condition
+
+      def initialize(attribute, condition)
+        @attribute = attribute
+        @condition = condition
+      end
+
+      def serialize_to(response, model, includes)
+        return if model.public_send(condition)
+        attribute.serialize_to(response, model, includes)
+      end
+    end
+
+    class Optional
+      attr_reader :attribute
+
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def serialize_to(response, model, includes)
+        return unless includes.include?(attribute.name)
+        attribute.serialize_to(response, model, includes)
+      end
+    end
+
+    class Config
+      attr_reader :attribute, :options
+
+      def initialize(attribute, options)
+        @attribute = attribute
+        @options = options
+      end
+
+      def to_attribute
+        nested = nested_attribute_from(attribute, options)
+        nested ? Config.new(nested, options).to_attribute : attribute
+      end
+
+      private
+
+      def nested_attribute_from(attribute, options)
+        if options.delete(:optional)
+          Optional.new(attribute)
+        elsif if_option
+          IfCondition.new(attribute, if_option)
+        elsif unless_option
+          UnlessCondition.new(attribute, unless_option)
+        end
+      end
+
+      def if_option
+        @if_option ||= options.delete(:if)
+      end
+
+      def unless_option
+        @unless_option ||= options.delete(:unless)
+      end
+    end
+
+    def self.from(name, options = {}, &block)
+      attribute =
+        if block
+          Synthesized.new(name, &block)
+        else
+          Simple.new(name)
+        end
+
+      Config.new(attribute, options).to_attribute
+    end
+  end
+end

data/lib/adequate_serialization/decorator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Decorator
+    class Null
+      def decorate(result)
+        result
+      end
+    end
+
+    class Attachments
+      attr_reader :attachments
+
+      def initialize(attachments)
+        @attachments = attachments
+      end
+
+      def decorate(result)
+        attachments.each do |name, attachment|
+          result[name] = attachment[result[:id]]
+        end
+
+        result
+      end
+    end
+
+    def self.from(attachments)
+      attachments.empty? ? Null.new : Attachments.new(attachments)
+    end
+  end
+end

data/lib/adequate_serialization/options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Options
+    class Opts
+      attr_reader :includes, :attachments, :options
+
+      def initialize(includes: [], attach: {}, **options)
+        @includes = Array(includes)
+        @attachments = attach
+        @options = options
+      end
+    end
+
+    def self.from(*opts)
+      Opts.new(opts[0] || {})
+    end
+
+    def self.null
+      Opts.new
+    end
+  end
+end

data/lib/adequate_serialization/rails/cache_key.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Rails
+    module CacheKey
+      def self.cacheable?(object)
+        if object.class < ActiveRecord::Base
+          object.has_attribute?(:updated_at)
+        else
+          object.respond_to?(:cache_key)
+        end
+      end
+
+      def self.for(object, includes = [])
+        includes.empty? ? object : [object, *includes]
+      end
+    end
+  end
+end

data/lib/adequate_serialization/rails/cache_step.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Rails
+    class CacheStep < Steps::PassthroughStep
+      def apply(response)
+        object = response.object
+        opts = response.opts
+
+        if opts.options[:multi_caching] || !CacheKey.cacheable?(object)
+          return apply_next(response)
+        end
+
+        ::Rails.cache.fetch(CacheKey.for(object, opts.includes)) do
+          apply_next(response)
+        end
+      end
+    end
+  end
+end

data/lib/adequate_serialization/rails/hook.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'adequate_serialization/rails/cache_key'
+require 'adequate_serialization/rails/cache_step'
+require 'adequate_serialization/rails/relation_serializer'
+
+module AdequateSerialization
+  module Rails
+    module RelationHook
+      def as_json(*options)
+        RelationSerializer.new(self).as_json(*options)
+      end
+    end
+
+    def self.hook_in!
+      ActiveRecord::Base.include(Serializable)
+      ActiveRecord::Relation.include(RelationHook)
+      AdequateSerialization.prepend(CacheStep)
+    end
+  end
+end

data/lib/adequate_serialization/rails/relation_serializer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Rails
+    class RelationSerializer
+      attr_reader :relation
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def as_json(*options)
+        return [] if relation.empty?
+
+        opts = Options.from(*options, multi_caching: true)
+        decorator = Decorator.from(opts.attachments)
+
+        response_for(opts, decorator)
+      end
+
+      private
+
+      def response_for(opts, decorator)
+        cache_keys = cache_keys_for(opts)
+
+        if cache_keys
+          cacheable_response_for(opts, decorator, cache_keys)
+        else
+          uncacheable_response_for(opts, decorator)
+        end
+      end
+
+      def cache_keys_for(opts)
+        relation.map do |record|
+          return nil unless CacheKey.cacheable?(record)
+          CacheKey.for(record, opts.includes)
+        end
+      end
+
+      def cacheable_response_for(opts, decorator, cache_keys)
+        results =
+          ::Rails.cache.fetch_multi(*cache_keys) do |(record, *)|
+            serialize(record, opts)
+          end
+
+        cache_keys.map do |cache_key|
+          decorator.decorate(results[cache_key])
+        end
+      end
+
+      def uncacheable_response_for(opts, decorator)
+        relation.map do |record|
+          decorator.decorate(serialize(record, opts))
+        end
+      end
+
+      def serialize(record, opts)
+        record.class.serializer.serialize(record, opts)
+      end
+    end
+  end
+end

data/lib/adequate_serialization/serializable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Serializable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def serializer
+        @serializer ||= const_get("#{name}Serializer").new
+      end
+    end
+
+    def as_json(*opts)
+      Steps.apply(self, *opts)
+    end
+  end
+end

data/lib/adequate_serialization/serializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  class Serializer
+    class << self
+      def attributes
+        @attributes ||= []
+      end
+
+      def attribute(*names, &block)
+        options =
+          if names.last.is_a?(Hash)
+            names.pop
+          else
+            {}
+          end
+
+        additions =
+          names.map! { |name| Attribute.from(name, options.dup, &block) }
+
+        @attributes = attributes + additions
+      end
+    end
+
+    def serialize(model, opts = Options.null)
+      self.class.attributes.each_with_object({}) do |attribute, response|
+        attribute.serialize_to(response, model, opts.includes)
+      end
+    end
+  end
+end

data/lib/adequate_serialization/steps.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Steps
+    def self.apply(object, *options)
+      opts = Options.from(*options)
+
+      response = Response.new(object, opts)
+      decorator = Decorator.from(opts.attachments)
+
+      decorator.decorate(AdequateSerialization.steps.apply(response))
+    end
+
+    class Response
+      attr_reader :object, :opts
+
+      def initialize(object, opts = {})
+        @object = object
+        @opts = opts
+      end
+
+      def mutate(new_object)
+        self.class.new(new_object, opts)
+      end
+    end
+  end
+
+  class << self
+    def prepend(step)
+      @steps = step.new(steps)
+    end
+
+    def steps
+      @steps ||= Steps::SerializeStep.new
+    end
+  end
+end

data/lib/adequate_serialization/steps/passthrough_step.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Steps
+    class LastStep
+      def apply(response)
+        response.object
+      end
+    end
+
+    class PassthroughStep
+      attr_reader :next_step
+
+      def initialize(next_step = LastStep.new)
+        @next_step = next_step
+      end
+
+      def apply(response)
+        apply_next(response)
+      end
+
+      private
+
+      def apply_next(response)
+        next_step.apply(response)
+      end
+    end
+  end
+end

data/lib/adequate_serialization/steps/serialize_step.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  module Steps
+    class SerializeStep < PassthroughStep
+      def apply(response)
+        object = response.object
+        serialized = object.class.serializer.serialize(object, response.opts)
+
+        apply_next(response.mutate(serialized))
+      end
+    end
+  end
+end

data/lib/adequate_serialization/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AdequateSerialization
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: adequate_serialization
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kevin Deisz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+description: 
+email:
+- kevin.deisz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- adequate_serialization.gemspec
+- bin/console
+- bin/setup
+- lib/adequate_serialization.rb
+- lib/adequate_serialization/attribute.rb
+- lib/adequate_serialization/decorator.rb
+- lib/adequate_serialization/options.rb
+- lib/adequate_serialization/rails/cache_key.rb
+- lib/adequate_serialization/rails/cache_step.rb
+- lib/adequate_serialization/rails/hook.rb
+- lib/adequate_serialization/rails/relation_serializer.rb
+- lib/adequate_serialization/serializable.rb
+- lib/adequate_serialization/serializer.rb
+- lib/adequate_serialization/steps.rb
+- lib/adequate_serialization/steps/passthrough_step.rb
+- lib/adequate_serialization/steps/serialize_step.rb
+- lib/adequate_serialization/version.rb
+homepage: https://github.com/kddeisz/adequate_serialization
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Serializes objects adequately
+test_files: []