blueprinter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f69da973430bcbb6be951377ccc7707e2d53228a
+  data.tar.gz: 818f307324662a8871d6abc6353cfbf52367cb33
+SHA512:
+  metadata.gz: a8ee5758ecba43bb06423d4fbe01ebfcabb918c2980775b75e494f75350e90b8348fd20685b6c0c083d47196b0ec75f99757020d6a9e82af7699964231b6f0dc
+  data.tar.gz: 63d4da14d7b9d1144068961c163ef2d6b9a04adbf3e21db33a57e68779d7c580f9c5491571c2154a453bd2c41ee76326dacc5f9f13c990f701a423709aaf74af

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Procore Technologies, Inc.
+
+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,230 @@
+[![CircleCI](https://circleci.com/gh/procore/blueprinter.svg?style=svg)](https://circleci.com/gh/procore/blueprinter)
+
+# Blueprinter
+Blueprinter is a JSON Object Presenter for Ruby that takes business objects and breaks them down into simple hashes and serializes them to JSON. It can be used in Rails in place of other serializers (like JBuilder or ActiveModelSerializers). It is designed to be simple, direct, and performant.
+
+It heavily relies on the idea of `views` which, similar to Rails views, are ways of predefining output for data in different contexts.
+
+## Documentation
+!TODO Link to the docs
+
+## Usage
+### Basic
+If you have an object you would like serialized, simply create a blueprint. Say, for example, you have a User record with the following attributes `[:uuid, :email, :first_name, :last_name, :password, :address]`.
+
+You may define a simple blueprint like so:
+
+```ruby
+class UserBlueprint < Blueprinter::Base
+  identifier :uuid
+
+  fields :first_name, :last_name, :email
+end
+```
+
+and then, in your code:
+```ruby
+puts UserBlueprint.render(user) # Output is a JSON string
+```
+
+And the output would look like:
+
+```json
+{
+  "uuid": "733f0758-8f21-4719-875f-262c3ec743af",
+  "email": "john.doe@some.fake.email.domain",
+  "first_name": "John",
+  "last_name": "Doe"
+}
+```
+
+### Views
+You may define different ouputs by utilizing views:
+```ruby
+class UserBlueprint < Blueprinter::Base
+  identifier :uuid
+  field :email, name: :login
+
+  view :normal do
+    fields :first_name, :last_name
+  end
+
+  view :extended do
+    include_view :normal
+    field :address
+    association :projects
+  end
+end
+```
+
+Usage:
+```ruby
+puts UserBlueprint.render(user, view: :extended)
+```
+
+Output:
+```json
+{
+  "uuid": "733f0758-8f21-4719-875f-262c3ec743af",
+  "address": "123 Fake St.",
+  "first_name": "John",
+  "last_name": "Doe",
+  "login": "john.doe@some.fake.email.domain"
+}
+```
+
+### Associations
+You may include associated objects. Say for example, a user has projects:
+```ruby
+class UserBlueprint < Blueprinter::Base
+  identifier :uuid
+  field :email, name: :login
+
+  view :normal do
+    fields :first_name, :last_name
+    association :projects
+  end
+end
+```
+
+Usage:
+```ruby
+puts UserBlueprint.render(user, view: :extended)
+```
+
+Output:
+```json
+{
+  "uuid": "733f0758-8f21-4719-875f-262c3ec743af",
+  "first_name": "John",
+  "last_name": "Doe",
+  "login": "john.doe@some.fake.email.domain",
+  "projects": [
+    {
+      "uuid": "dca94051-4195-42bc-a9aa-eb99f7723c82",
+      "name": "Beach Cleanup"
+    },
+    {
+      "uuid": "eb881bb5-9a51-4d27-8a29-b264c30e6160",
+      "name": "Storefront Revamp"
+    }
+  ]
+}
+```
+
+### Defining a field directly in the Blueprint
+
+You can define a field directly in the Blueprint by passing it a block. This is especially useful if the object does not already have such an attribute or method defined, and you want to define it specifically for use with the Blueprint. For example:
+
+```ruby
+class UserBlueprint < Blueprinter::Base
+  identifier :uuid
+  field :full_name do |user|
+    "#{user.first_name} #{user.last_name}"
+  end
+end
+```
+
+Usage:
+
+```ruby
+puts UserBlueprint.render(user)
+```
+
+Output:
+
+```json
+{
+  "uuid": "733f0758-8f21-4719-875f-262c3ec743af",
+  "full_name": "John Doe"
+}
+```
+
+### Passing additional properties to `render`
+
+`render` takes an options hash which you can pass additional properties, allowing you to utilize those additional properties in the `field` block. For example:
+
+```ruby
+class UserBlueprint < Blueprinter::Base
+  identifier :uuid
+  field(:company_name) do |_user, options|
+    options[:company].name
+  end
+end
+```
+
+Usage:
+
+```ruby
+puts UserBlueprint.render(user, company: company)
+```
+
+Output:
+
+```json
+{
+  "uuid": "733f0758-8f21-4719-875f-262c3ec743af",
+  "company_name": "My Company LLC"
+}
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'blueprinter'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install blueprinter
+```
+
+You should also have `require 'json'` already in your project if you are not using Rails or if you are not using Oj.
+
+## OJ
+
+By default, Blueprinter will be calling `JSON.generate(object)` internally and it expects that you have `require 'json'` already in your project's code. You may use `Oj` to generate in place of `JSON` like so:
+
+```ruby
+require 'oj' # you can skip this if OJ has already been required.
+
+Blueprinter.configure do |config|
+  config.generator = Oj # default is JSON
+end
+```
+
+Ensure that you have the `Oj` gem installed in your Gemfile if you haven't already:
+
+```ruby
+# Gemfile
+gem 'oj'
+```
+
+## Documentation
+
+We use [Yard](https://yardoc.org/) for documentation. Here are the following
+documentation rules:
+
+- Document all public methods we expect to be utilized by the end developers.
+- Methods that are not set to private due to ruby visibility rule limitations should be marked with `@api private`.
+
+## Contributing
+Feel free to browse the issues, converse, and make pull requests. If you need help, first please see if there is already an issue for your problem. Otherwise, go ahead and make a new issue.
+
+### Tests
+You can run tests with `bundle exec rake`.
+
+### Maintain The Docs
+We use Yard for documentation. Here are the following documentation rules:
+
+- Document all public methods we expect to be utilized by the end developers.
+- Methods that are not set to private due to ruby visibility rule limitations should be marked with `@api private`.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rdoc/task'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Blueprinter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--pattern spec/**/*_spec.rb'
+end
+
+Rake::TestTask.new(:benchmarks) do |t|
+  t.libs << 'spec'
+  t.pattern = 'spec/benchmarks/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :spec

data/lib/blueprinter.rb

@@ -0,0 +1,5 @@
+require_relative 'blueprinter/configuration'
+require_relative 'blueprinter/base'
+
+module Blueprinter
+end

data/lib/blueprinter/base.rb

@@ -0,0 +1,294 @@
+require_relative 'blueprinter_error'
+require_relative 'helpers/active_record_helpers'
+require_relative 'serializer'
+require_relative 'serializers/association_serializer'
+require_relative 'serializers/auto_serializer'
+require_relative 'serializers/block_serializer'
+require_relative 'serializers/hash_serializer'
+require_relative 'serializers/public_send_serializer'
+require_relative 'field'
+require_relative 'view'
+require_relative 'view_collection'
+require_relative 'optimizer'
+
+module Blueprinter
+  class Base
+    include ActiveRecordHelpers
+
+    # Specify a field or method name used as an identifier. Usually, this is
+    # something like :id
+    #
+    # Note: identifiers are always rendered and considerered their own view,
+    # similar to the :default view.
+    #
+    # @param method [Symbol] the method or field used as an identifier that you
+    #   want to set for serialization.
+    # @param name [Symbol] to rename the identifier key in the JSON
+    #   output. Defaults to method given.
+    # @param serializer [AssociationSerializer,AutoSerializer,BlockSerializer,HashSerializer,PublicSendSerializer]
+    #   Kind of serializer to use.
+    #   Either define your own or use Blueprinter's premade serializers.
+    #   Defaults to AutoSerializer
+    #
+    # @example Specifying a uuid as an identifier.
+    #   class UserBlueprint < Blueprinter::Base
+    #     identifier :uuid
+    #     # other code
+    #   end
+    #
+    # @return [Field] A Field object
+    def self.identifier(method, name: method, serializer: AutoSerializer)
+      view_collection[:identifier] << Field.new(method, name, serializer)
+    end
+
+    # Specify a field or method name to be included for serialization.
+    # Takes a required method and an option.
+    #
+    # @param method [Symbol] the field or method name you want to include for
+    #   serialization.
+    # @param options [Hash] options to overide defaults.
+    # @option options [AssociationSerializer,BlockSerializer,HashSerializer,PublicSendSerializer] :serializer
+    #   Kind of serializer to use.
+    #   Either define your own or use Blueprinter's premade serializers. The
+    #   Default serializer is AutoSerializer
+    # @option options [Symbol] :name Use this to rename the method. Useful if
+    #   if you want your JSON key named differently in the output than your
+    #   object's field or method name.
+    # @yield [Object] The object passed to `render` is also passed to the
+    #   block.
+    #
+    # @example Specifying a user's first_name to be serialized.
+    #   class UserBlueprint < Blueprinter::Base
+    #     field :first_name
+    #     # other code
+    #   end
+    #
+    # @example Passing a block to be evaluated as the value.
+    #   class UserBlueprint < Blueprinter::Base
+    #     field :full_name {|obj| "#{obj.first_name} #{obj.last_name}"}
+    #     # other code
+    #   end
+    #
+    # @return [Field] A Field object
+    def self.field(method, options = {}, &block)
+      options = if block_given?
+        {name: method, serializer: BlockSerializer, block: {method => block}}
+      else
+        {name: method, serializer: AutoSerializer}
+      end.merge(options)
+      current_view << Field.new(method,
+                                options[:name],
+                                options[:serializer],
+                                options)
+    end
+
+    # Specify an associated object to be included for serialization.
+    # Takes a required method and an option.
+    #
+    # @param method [Symbol] the association name
+    # @param options [Hash] options to overide defaults.
+    # @option options [Symbol] :name Use this to rename the association in the
+    #   JSON output.
+    # @option options [Symbol] :view Specify the view to use or fall back to
+    #   to the :default view.
+    #
+    # @example Specifying an association
+    #   class UserBlueprint < Blueprinter::Base
+    #     # code
+    #     association :vehicles, view: :extended
+    #     # code
+    #   end
+    #
+    # @return [Field] A Field object
+    def self.association(method, options = {})
+      name = options.delete(:name) || method
+      current_view << Field.new(method,
+                                       name,
+                                       AssociationSerializer,
+                                       options.merge(association: true))
+    end
+
+    # Generates a JSON formatted String.
+    # Takes a required object and an optional view.
+    #
+    # @param object [Object] the Object to serialize upon.
+    # @param options [Hash] the options hash which requires a :view. Any
+    #   additional key value pairs will be exposed during serialization.
+    # @option options [Symbol] :view Defaults to :default.
+    #   The view name that corresponds to the group of
+    #   fields to be serialized.
+    #
+    # @example Generating JSON with an extended view
+    #   post = Post.all
+    #   Blueprinter::Base.render post, view: :extended
+    #   # => "[{\"id\":1,\"title\":\"Hello\"},{\"id\":2,\"title\":\"My Day\"}]"
+    #
+    # @return [String] JSON formatted String
+    def self.render(object, options = {})
+      view_name = options.delete(:view) || :default
+      jsonify(prepare(object, view_name: view_name, local_options: options))
+    end
+
+    # This is the magic method that converts complex objects into a simple hash
+    # ready for JSON conversion.
+    #
+    # Note: we accept view (public interface) that is in reality a view_name,
+    # so we rename it for clarity
+    #
+    # @api private
+    def self.prepare(object, view_name:, local_options:)
+      unless view_collection.has_view? view_name
+        raise BlueprinterError, "View '#{view_name}' is not defined"
+      end
+      fields = view_collection.fields_for(view_name)
+      prepared_object = Optimizer.optimize(object, fields: fields)
+      prepared_object = include_associations(prepared_object, view_name: view_name)
+      if array_like?(object)
+        prepared_object.map do |obj|
+          object_to_hash(obj,
+                         view_name: view_name,
+                         local_options: local_options)
+        end
+      else
+        object_to_hash(prepared_object,
+                       view_name: view_name,
+                       local_options: local_options)
+      end
+    end
+
+    # Specify one or more field/method names to be included for serialization.
+    # Takes at least one field or method names.
+    #
+    # @param method [Symbol] the field or method name you want to include for
+    #   serialization.
+    #
+    # @example Specifying a user's first_name and last_name to be serialized.
+    #   class UserBlueprint < Blueprinter::Base
+    #     fields :first_name, :last_name
+    #     # other code
+    #   end
+    #
+    # @return [Array<Symbol>] an array of field names
+    def self.fields(*field_names)
+      field_names.each do |field_name|
+        current_view << Field.new(field_name, field_name, AutoSerializer)
+      end
+    end
+
+    # @api private
+    def self.associations(view_name = :default)
+      view_collection.fields_for(view_name).select { |f| f.options[:association] }
+    end
+
+    # Specify another view that should be mixed into the current view.
+    #
+    # @param view_name [Symbol] the view to mix into the current view.
+    #
+    # @example Including a normal view into an extended view.
+    #   class UserBlueprint < Blueprinter::Base
+    #     # other code...
+    #     view :normal do
+    #       fields :first_name, :last_name
+    #     end
+    #     view :extended do
+    #       include_view :normal # include fields specified from above.
+    #       field :description
+    #     end
+    #     #=> [:first_name, :last_name, :description]
+    #   end
+    #
+    # @return [Array<Symbol>] an array of view names.
+    def self.include_view(view_name)
+      current_view.include_view(view_name)
+    end
+
+
+    # Exclude a field that was mixed into the current view.
+    #
+    # @param field_name [Symbol] the field to exclude from the current view.
+    #
+    # @example Excluding a field from being included into the current view.
+    #   view :normal do
+    #     fields :position, :company
+    #   end
+    #   view :special do
+    #     include_view :normal
+    #     field :birthday
+    #     exclude :position
+    #   end
+    #   #=> [:company, :birthday]
+    #
+    # @return [Array<Symbol>] an array of field names
+    def self.exclude(field_name)
+      current_view.exclude_field(field_name)
+    end
+
+    # Specify a view and the fields it should have.
+    # It accepts a view name and a block. The block should specify the fields.
+    #
+    # @param view_name [Symbol] the view name
+    # @yieldreturn [#fields,#field,#include_view,#exclude] Use this block to
+    #   specify fields, include fields from other views, or exclude fields.
+    #
+    # @example Using views
+    #   view :extended do
+    #     fields :position, :company
+    #     include_view :normal
+    #     exclude :first_name
+    #   end
+    #
+    # @return [View] a Blueprinter::View object
+    def self.view(view_name)
+      @current_view = view_collection[view_name]
+      yield
+      @current_view = view_collection[:default]
+    end
+
+    private
+
+    def self.object_to_hash(object, view_name:, local_options:)
+      view_collection.fields_for(view_name).each_with_object({}) do |field, hash|
+        hash[field.name] = field.serialize(object, local_options)
+      end
+    end
+    private_class_method :object_to_hash
+
+    def self.include_associations(object, view_name:)
+      unless defined?(ActiveRecord::Base) &&
+          object.is_a?(ActiveRecord::Base) &&
+          object.respond_to?(:klass)
+        return object
+      end
+      # TODO: Do we need to support more than `eager_load` ?
+      fields_to_include = associations(view).select { |a|
+        a.options[:include] != false
+      }.map(&:method)
+      if !fields_to_include.empty?
+        object.eager_load(*fields_to_include)
+      else
+        object
+      end
+    end
+    private_class_method :include_associations
+
+    def self.jsonify(blob)
+      Blueprinter.configuration.generator.generate(blob)
+    end
+    private_class_method :jsonify
+
+    def self.current_view
+      @current_view ||= view_collection[:default]
+    end
+    private_class_method :current_view
+
+    def self.view_collection
+      @view_collection ||= ViewCollection.new
+    end
+    private_class_method :view_collection
+
+    def self.array_like?(object)
+      object.is_a?(Array) || active_record_relation?(object)
+    end
+    private_class_method :array_like?
+  end
+end

data/lib/blueprinter/blueprinter_error.rb

@@ -0,0 +1,3 @@
+module Blueprinter
+  class BlueprinterError < StandardError; end
+end

data/lib/blueprinter/configuration.rb

@@ -0,0 +1,17 @@
+module Blueprinter
+  class Configuration
+    attr_accessor :generator
+
+    def initialize
+      @generator = JSON
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+end

data/lib/blueprinter/field.rb

@@ -0,0 +1,14 @@
+# @api private
+class Blueprinter::Field
+  attr_reader :method, :name, :serializer, :options
+  def initialize(method, name, serializer, options = {})
+    @method = method
+    @name = name
+    @serializer = serializer
+    @options = options
+  end
+
+  def serialize(object, local_options)
+    serializer.serialize(method, object, local_options, options)
+  end
+end

data/lib/blueprinter/helpers/active_record_helpers.rb

@@ -0,0 +1,18 @@
+module Blueprinter
+  module ActiveRecordHelpers
+    def self.included(base)
+      base.extend(SingletonMethods)
+    end
+
+    def active_record_relation?(object)
+      self.class.active_record_relation?(object)
+    end
+
+    module SingletonMethods
+      def active_record_relation?(object)
+        !!(defined?(ActiveRecord::Relation) &&
+          object.is_a?(ActiveRecord::Relation))
+      end
+    end
+  end
+end

data/lib/blueprinter/optimizer.rb

@@ -0,0 +1,30 @@
+module Blueprinter
+  # @api private
+  class Optimizer
+    include ActiveRecordHelpers
+    class << self
+      def optimize(object, fields:)
+        return object unless active_record_relation?(object)
+        select_columns = (active_record_attributes_for(object) &
+                         fields.map(&:method)) +
+                         required_lookup_attributes_for(object)
+        object.select(*select_columns)
+      end
+
+      private
+
+      def active_record_attributes_for(object)
+        object.klass.column_names.map(&:to_sym)
+      end
+
+      def required_lookup_attributes_for(object)
+        # TODO: We may not need all four of these
+        lookup_values = (object.includes_values +
+                         object.preload_values +
+                         object.joins_values +
+                         object.eager_load_values).uniq
+        lookup_values.map {|value| object.reflections[value.to_s].foreign_key}
+      end
+    end
+  end
+end

data/lib/blueprinter/serializer.rb

@@ -0,0 +1,13 @@
+# @api private
+class Blueprinter::Serializer
+  def initialize
+  end
+
+  def serialize(field_name, object, local_options, options={})
+    fail NotImplementedError, "A serializer must implement #serialize"
+  end
+
+  def self.serialize(field_name, object, local_options, options={})
+    self.new.serialize(field_name, object, local_options, options)
+  end
+end

data/lib/blueprinter/serializers/association_serializer.rb

@@ -0,0 +1,10 @@
+class Blueprinter::AssociationSerializer < Blueprinter::Serializer
+  def serialize(association_name, object, local_options, options={})
+    if options[:blueprint]
+      view = options[:view] || :default
+      options[:blueprint].prepare(object.public_send(association_name), view_name: view, local_options: local_options)
+    else
+      object.public_send(association_name)
+    end
+  end
+end

data/lib/blueprinter/serializers/auto_serializer.rb

@@ -0,0 +1,8 @@
+module Blueprinter
+  class AutoSerializer < Blueprinter::Serializer
+    def serialize(field_name, object, local_options, options = {})
+      serializer = object.is_a?(Hash) ? HashSerializer : PublicSendSerializer
+      serializer.serialize(field_name, object, local_options, options = {})
+    end
+  end
+end

data/lib/blueprinter/serializers/block_serializer.rb

@@ -0,0 +1,5 @@
+class Blueprinter::BlockSerializer < Blueprinter::Serializer
+  def serialize(field_name, object, local_options, options = {})
+    options[:block][field_name].call(object, local_options)
+  end
+end

data/lib/blueprinter/serializers/hash_serializer.rb

@@ -0,0 +1,5 @@
+class Blueprinter::HashSerializer < Blueprinter::Serializer
+  def serialize(field_name, object, local_options, options = {})
+    object[field_name] || object[field_name.to_s]
+  end
+end

data/lib/blueprinter/serializers/public_send_serializer.rb

@@ -0,0 +1,5 @@
+class Blueprinter::PublicSendSerializer < Blueprinter::Serializer
+  def serialize(field_name, object, local_options, options = {})
+    object.public_send(field_name)
+  end
+end

data/lib/blueprinter/version.rb

@@ -0,0 +1,3 @@
+module Blueprinter
+  VERSION = '0.1.0'
+end

data/lib/blueprinter/view.rb

@@ -0,0 +1,29 @@
+module Blueprinter
+  # @api private
+  class View
+    attr_reader :excluded_field_names, :fields, :included_view_names, :name
+
+    def initialize(name, fields: {}, included_view_names: [], excluded_view_names: [])
+      @name = name
+      @fields = fields
+      @included_view_names = included_view_names
+      @excluded_field_names = excluded_view_names
+    end
+
+    def include_view(view_name)
+      included_view_names << view_name
+    end
+
+    def exclude_field(field_name)
+      excluded_field_names << field_name
+    end
+
+    def <<(field)
+      if fields.has_key?(field.name)
+        raise BlueprinterError,
+          "Field #{field.name} already defined on #{name}"
+      end
+      fields[field.name] = field
+    end
+  end
+end

data/lib/blueprinter/view_collection.rb

@@ -0,0 +1,46 @@
+module Blueprinter
+  # @api private
+  class ViewCollection
+    attr_reader :views
+    def initialize
+      @views = {
+        identifier: View.new(:identifier),
+        default: View.new(:default)
+      }
+    end
+
+    def has_view?(view_name)
+      views.has_key? view_name
+    end
+
+    def fields_for(view_name)
+      identifier_fields + sortable_fields(view_name).values.sort_by(&:name)
+    end
+
+    def [](view_name)
+      @views[view_name] ||= View.new(view_name)
+    end
+
+    private
+
+    def identifier_fields
+      views[:identifier].fields.values
+    end
+
+    def sortable_fields(view_name)
+      fields = views[:default].fields
+      fields = fields.merge(views[view_name].fields)
+      views[view_name].included_view_names.each do |included_view_name|
+        if view_name != included_view_name
+          fields = fields.merge(sortable_fields(included_view_name))
+        end
+      end
+
+      views[view_name].excluded_field_names.each do |name|
+        fields.delete(name)
+      end
+
+      fields
+    end
+  end
+end

data/lib/rabbit_painter.rb

@@ -0,0 +1,14 @@
+=begin
+module RabbitPainter
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    attr_reader :serializer
+    def self.serializer(klass)
+      @serializer = klass
+    end
+  end
+end
+=end

data/lib/tasks/blueprinter_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :blueprinter do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: blueprinter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Hess
+- Derek Carter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.11
+description: Blueprinter is a JSON Object Presenter for Ruby that takes business objects
+  and breaks them down into simple hashes and serializes them to JSON. It can be used
+  in Rails in place of other serializers (like JBuilder or ActiveModelSerializers).
+  It is designed to be simple, direct, and performant.
+email:
+- adamhess1991@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/blueprinter.rb
+- lib/blueprinter/base.rb
+- lib/blueprinter/blueprinter_error.rb
+- lib/blueprinter/configuration.rb
+- lib/blueprinter/field.rb
+- lib/blueprinter/helpers/active_record_helpers.rb
+- lib/blueprinter/optimizer.rb
+- lib/blueprinter/serializer.rb
+- lib/blueprinter/serializers/association_serializer.rb
+- lib/blueprinter/serializers/auto_serializer.rb
+- lib/blueprinter/serializers/block_serializer.rb
+- lib/blueprinter/serializers/hash_serializer.rb
+- lib/blueprinter/serializers/public_send_serializer.rb
+- lib/blueprinter/version.rb
+- lib/blueprinter/view.rb
+- lib/blueprinter/view_collection.rb
+- lib/rabbit_painter.rb
+- lib/tasks/blueprinter_tasks.rake
+homepage: https://github.com/procore/blueprinter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Simple Fast Declarative Serialization Library
+test_files: []