yaks 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44bddcd54510d2f8a9fbd3a928874218eb12f946
+  data.tar.gz: 3d6578acf4bb8b7bb22e6b81e84e747321b6a456
+SHA512:
+  metadata.gz: 48980782c7367fef882d2bc46cde48df3d13280fd19e196246461c774e7f81f2d300800a3c3f7c6f1560fd0ecf8b60afc9628f787110768f372b7c250766269d
+  data.tar.gz: 9733522792a868b261d48e429db1416104b62b2b8c80689a33b9c8dc8ede9d70d5173f16cded562b01adfa7aa5827cb0e59b1fac84ed0722538f9c409470420e

data/.gitignore

@@ -0,0 +1 @@
+.bundle

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'hamster', path: '/home/arne/github/hamster'

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    yaks (0.0.0)
+      concord (~> 0.1.4)
+      hamster (~> 0.4.3)
+      inflection (~> 1.0.0)
+
+PATH
+  remote: /home/arne/github/hamster
+  specs:
+    hamster (0.4.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    adamantium (0.1.0)
+      ice_nine (~> 0.9)
+      thread_safe (~> 0.1.2)
+    atomic (1.1.14)
+    axiom-types (0.0.5)
+      descendants_tracker (~> 0.0.1)
+      ice_nine (~> 0.9)
+    backports (3.3.5)
+    coercible (0.2.0)
+      backports (~> 3.0, >= 3.1.0)
+      descendants_tracker (~> 0.0.1)
+    concord (0.1.4)
+      adamantium (~> 0.1)
+      equalizer (~> 0.0.7)
+    descendants_tracker (0.0.3)
+    diff-lcs (1.2.5)
+    equalizer (0.0.8)
+    ice_nine (0.10.0)
+    inflection (1.0.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    thread_safe (0.1.3)
+      atomic
+    virtus (1.0.0)
+      axiom-types (~> 0.0.5)
+      coercible (~> 0.2)
+      descendants_tracker (~> 0.0.1)
+      equalizer (~> 0.0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hamster!
+  rspec
+  virtus
+  yaks!

data/README.md

@@ -0,0 +1,106 @@
+# Yankee Alpha Kilo Serializers
+
+```ruby
+class ShowSerializer < Yaks::Serialize
+  attributes :id, :name, :description, :dates
+
+  has_many :events
+  has_one :event_category
+
+  def description
+    object.description(:long)
+  end
+
+  def dates
+    events.map(&:day)
+  end
+end
+
+class EventSerializer < Yaks::Serializer
+  attributes :id, :name
+end
+
+class EventCategorySerializer < Yaks::Serializer
+  attributes :id, :name
+end
+
+json = JSON.dump(
+  Yaks::Dumper.new(format: :json_api).dump('shows', Show.upcoming)
+)
+```
+
+## Non-Features
+
+* No core extensions
+* Minimal dependencies
+* Only serializes what explicitly has a Serializer, will never call to_json/as_json
+* Adding extra output formats does not require altering existing code
+
+## Formats
+
+* :json_api
+
+```json
+{
+   "shows" : [
+      {
+         "dates" : [ "next Sunday" ],
+         "name" : "Piglet gets his groove back",
+         "id" : 5,
+         "description" : "Once in a lifetime...",
+         "links" : {
+            "event_category" : 2,
+            "events" : [ 7 ]
+         }
+      }
+   ],
+   "linked" : {
+      "event_categories" : [
+         {
+            "name" : "Drama",
+            "id" : 2
+         }
+      ],
+      "events" : [
+         {
+            "name" : "Sneak preview",
+            "id" : 7
+         }
+      ]
+   }
+}
+```
+
+* :ams_compat
+
+```json
+{
+   "shows" : [
+      {
+         "dates" : [ "next Sunday" ],
+         "name" : "Piglet gets his groove back",
+         "id" : 5,
+         "description" : null,
+         "event_ids" : [ 7 ],
+         "event_category_id" : 2
+      }
+   ],
+   "event_categories" : [{
+         "name" : "Drama",
+         "id" : 2
+   }],
+   "events" : [{
+         "Name" : "Sneak preview",
+         "id" : 7
+   }]
+}
+
+## Maturity
+
+Infantile. Crazy what these kids get up to, though.
+
+requires current master of Hamster.
+
+## License
+
+MIT

data/lib/yaks/dumper.rb

@@ -0,0 +1,23 @@
+module Yaks
+  class Dumper
+    include Util
+
+    def initialize(options = {})
+      @lookup       = options.fetch(:serializer_lookup) { Yaks.default_serializer_lookup }
+      format        = options.fetch(:format) { :json_api }
+      @format       = Yaks.const_get("Fold#{camelize(format.to_s)}") if format.is_a?(Symbol)
+      @options      = options
+    end
+
+    def dump(type, objects)
+      serializer = @lookup.(type).new(@options.merge(root_key: type))
+      Primitivize.(
+        @format.new(
+          serializer.serializable_collection(objects)
+        ).fold
+      )
+    end
+    alias call dump
+
+  end
+end

data/lib/yaks/fold_ams_compat.rb

@@ -0,0 +1,33 @@
+module Yaks
+  class FoldAmsCompat < FoldJsonApi
+    include Concord.new(:collection)
+    include Util
+    extend Forwardable
+
+    def_delegator :collection, :root_key
+
+    def fold
+      Hamster.hash(
+        root_key => collection.map(&method(:fold_object)),
+      ).merge(
+        fold_associated_objects
+      )
+    end
+
+    private
+
+    def fold_object(object)
+      object.attributes.merge(link_ids(object))
+    end
+
+    def fold_association_ids(hash, association)
+      name = singular(association.name.to_s)
+      if association.one?
+        hash.put(name + '_id', association.identities.first)
+      else
+        hash.put(name + '_ids', association.identities)
+      end
+    end
+
+  end
+end

data/lib/yaks/fold_json_api.rb

@@ -0,0 +1,61 @@
+module Yaks
+  class FoldJsonApi
+    include Concord.new(:collection)
+    include Util
+    extend Forwardable
+
+    def_delegator :collection, :root_key
+
+    def fold
+      Hamster.hash(
+        root_key => collection.map(&method(:fold_object)),
+        "linked" => fold_associated_objects
+      )
+    end
+
+    private
+
+    def fold_object(object)
+      if object.has_associated_objects?
+        object.attributes.merge(Hamster.hash(links: link_ids(object)))
+      else
+        object.attributes
+      end
+    end
+
+    def link_ids(object)
+      object.associations.reduce(
+        Hamster.hash,
+        &method(:fold_association_ids)
+      )
+    end
+
+    def fold_association_ids(hash, association)
+      if association.one?
+        hash.put(association.name, association.identities.first)
+      else
+        hash.put(association.name, association.identities)
+      end
+    end
+
+    def fold_associated_objects
+      association_names = Hamster.set(*
+        collection.flat_map do |object|
+          object.associations.map{|ass| [ass.name, ass.one?] }
+        end
+      )
+      Hamster.hash(
+        association_names.map do |name, one|
+          [
+            one ? pluralize(name.to_s) : name,
+            Hamster.set(*
+              collection.flat_map do |object|
+                object.associated_objects(name)
+              end
+            ).map(&method(:fold_object))
+          ]
+        end
+      )
+    end
+  end
+end

data/lib/yaks/primitivize.rb

@@ -0,0 +1,24 @@
+module Yaks
+  class Primitivize
+    def self.call(object)
+      new.call(object)
+    end
+
+    def call(object)
+      case object
+      when String, TrueClass, FalseClass, NilClass, Numeric
+        object
+      when Symbol
+        object.to_s
+      when Hash, Hamster::Hash
+        object.to_enum(:each).with_object({}) do |(key, value), output|
+          output[self.(key)] = self.(value)
+        end
+      when Enumerable, Hamster::Enumerable
+        object.map(&method(:call)).to_a
+      else
+        raise "don't know how to turn #{object.class} (#{object.inspect}) into a primitive"
+      end
+    end
+  end
+end

data/lib/yaks/serializable_association.rb

@@ -0,0 +1,21 @@
+module Yaks
+  class SerializableAssociation
+    include Concord.new(:collection, :one)
+    extend Forwardable
+
+    def_delegator :collection, :root_key, :name
+    def_delegators :collection, :identity_key, :map, :objects, :empty?
+
+    def one?
+      one
+    end
+
+    def identities
+      map(&method(:identity))
+    end
+
+    def identity(object)
+      object[identity_key]
+    end
+  end
+end

data/lib/yaks/serializable_collection.rb

@@ -0,0 +1,10 @@
+module Yaks
+  class SerializableCollection
+    include Concord.new(:root_key, :identity_key, :objects)
+    extend Forwardable
+
+    public :root_key, :identity_key
+
+    def_delegators :objects, :map, :flat_map, :empty?
+  end
+end

data/lib/yaks/serializable_object.rb

@@ -0,0 +1,18 @@
+module Yaks
+  class SerializableObject
+    include Concord.new(:attributes, :associations)
+    extend Forwardable
+
+    public :attributes, :associations
+
+    def_delegator :attributes, :[]
+
+    def associated_objects(association_name)
+      associations.detect {|association| association_name == association.name }.objects
+    end
+
+    def has_associated_objects?
+      !associations.all?(&:empty?)
+    end
+  end
+end

data/lib/yaks/serializer/class_methods.rb

@@ -0,0 +1,76 @@
+module Yaks
+  class Serializer
+    module ClassMethods
+      include Util
+
+      protected
+
+      def inherited(desc)
+        attributes
+        has_one
+      end
+
+      def attributes(*attrs)
+        _attributes.concat attrs
+
+        attrs.each do |attr|
+          unless method_defined?(attr)
+            define_method attr do
+              object.send attr
+            end
+          end
+        end
+      end
+
+      def has_one(*attrs)
+        _associations.concat(attrs.map {|a| [:has_one, a] })
+        attrs.each do |attr|
+          unless method_defined?(attr)
+            define_method attr do
+              object.send attr
+            end
+          end
+        end
+      end
+
+      def has_many(*attrs)
+        _associations.concat(attrs.map {|a| [:has_many, a] })
+        attrs.each do |attr|
+          unless method_defined?(attr)
+            define_method attr do
+              object.send attr
+            end
+          end
+        end
+      end
+
+      def root_key(key)
+        @root_key = key
+      end
+
+      def identity_key(id_key)
+        @identity_key = id_key
+      end
+
+      public
+
+      def _attributes
+        @attributes ||= []
+      end
+
+      def _associations
+        @associations ||= []
+      end
+
+      def _root_key
+        @root_key ||
+          pluralize(underscore(self.name.sub(/Serializer$/, '')))
+      end
+
+      def _identity_key
+        @identity_key || :id
+      end
+
+    end
+  end
+end

data/lib/yaks/serializer.rb

@@ -0,0 +1,64 @@
+module Yaks
+  class Serializer
+    include Yaks
+    extend ClassMethods
+
+    attr_accessor :object
+    attr_reader :serializer_lookup, :root_key
+
+    def initialize(options = {})
+      @serializer_lookup = options.fetch(:serializer_lookup) { Yaks.default_serializer_lookup }
+      @root_key = options.fetch(:root_key) { self.class._root_key }
+    end
+
+    def identity_key
+      self.class._identity_key
+    end
+
+    def attributes
+      self.class._attributes
+    end
+
+    def associations
+      self.class._associations
+    end
+
+    def filter(attributes)
+      attributes
+    end
+
+    def serializable_collection(enumerable)
+      SerializableCollection.new(root_key, identity_key, enumerable.map(&method(:serializable_object)))
+    end
+
+    def serializable_object(object)
+      self.object = object
+      SerializableObject.new(
+        serializable_attributes(object),
+        serializable_associations(object)
+      )
+    end
+
+    def serializable_attributes(object)
+      Hash(filter(attributes).map {|attr| [attr, send(attr)] })
+    end
+
+    def serializable_associations(object)
+      Hamster.enumerate(filter(associations.map(&:last)).each).map do |name|
+        type = associations.detect {|type, n| name == n }.first
+        if type == :has_one
+          obj        = send(name)
+          serializer = serializer_lookup.(obj).new
+          objects    = List(serializer.serializable_object(obj))
+        else
+          serializer = nil
+          objects = Hamster.enumerate(send(name).each).map do |obj|
+            serializer ||= serializer_lookup.(obj).new
+            serializer.serializable_object(obj)
+          end
+        end
+        SerializableAssociation.new( SerializableCollection.new(name, :id, objects), type == :has_one )
+      end
+    end
+  end
+end

data/lib/yaks/util.rb

@@ -0,0 +1,21 @@
+module Yaks
+  module Util
+    extend self
+    extend Forwardable
+
+    def_delegators Inflection, :singular, :singularize, :pluralize
+
+    def underscore(str)
+      str.gsub(/::/, '/')
+         .gsub(/(?<!^)([A-Z])(?=[a-z$])|(?<=[a-z])([A-Z])/, '_\1\2')
+         .tr("-", "_")
+         .downcase!
+    end
+
+    def camelize(str)
+      str.gsub(/\/(.?)/)      { "::#{ $1.upcase }" }
+         .gsub!(/(?:^|_)(.)/) { $1.upcase          }
+    end
+
+  end
+end

data/lib/yaks/version.rb

@@ -0,0 +1,3 @@
+module Yaks
+  VERSION = '0.0.0'
+end

data/lib/yaks.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+
+require 'hamster'
+require 'concord'
+require 'inflection'
+
+module Yaks
+  Undefined = Object.new
+
+  class << self
+    def default_serializer_lookup(obj = Undefined)
+      return method(:default_serializer_lookup) if obj == Undefined
+      if obj.respond_to?(:to_str)
+        Object.const_get("#{Util.singular(Util.camelize(obj.to_str))}Serializer")
+      else
+        Object.const_get("#{obj.class.name}Serializer")
+      end
+    end
+  end
+
+  def List(*args)
+    Hamster.list(*args)
+  end
+
+  def Hash(*args)
+    Hamster.hash(*args)
+  end
+
+  def Set(*args)
+    Hamster.set(*args)
+  end
+end
+
+require 'yaks/util'
+require 'yaks/serializable_collection'
+require 'yaks/serializable_object'
+require 'yaks/serializable_association'
+require 'yaks/fold_json_api'
+require 'yaks/fold_ams_compat'
+require 'yaks/serializer/class_methods'
+require 'yaks/serializer'
+require 'yaks/primitivize'
+require 'yaks/dumper'

data/spec/integration_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module IntegrationRunner
+  def run!
+    specify do
+      tests.each do |type, objects, result|
+        expect(Yaks::Dumper.new(format: format).call(type, objects)).to eq result
+      end
+    end
+  end
+end
+
+describe Yaks, 'integration tests' do
+  include_context 'fixtures'
+
+  context 'json api' do
+    extend IntegrationRunner
+
+    let(:format) { :json_api }
+    let(:tests) do
+      [
+        ['friends', [john],
+          {
+            "friends" => [
+              { "name"  => "john",
+                "id"    => 1,
+                "links" => {
+                  'pets'      => [2, 3],
+                  'pet_peeve' => 4
+                }
+              }
+            ],
+            "linked" => {
+              "pets" => [
+                { "name"    => "boingboing",
+                  "species" => "dog",
+                  "id"      => 2
+                },
+                { "name"    => "wassup",
+                  "species" => "cat",
+                  "id"      => 3
+                }
+              ],
+              "pet_peeve" => [
+                { "id"   => 4,
+                  "type" => "parsing with regexps"}
+              ]
+            }
+          }
+        ]
+      ]
+    end
+
+    run!
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+
+ROOT = Pathname(__FILE__).join('../..')
+
+$LOAD_PATH.unshift(ROOT.join('lib'))
+
+require 'yaks'
+require 'virtus'
+
+require_relative 'support/models'
+require_relative 'support/serializers'
+require_relative 'support/fixtures'

data/spec/support/fixtures.rb

@@ -0,0 +1,6 @@
+shared_context 'fixtures' do
+  let(:john)       { Friend.new(id: 1, name: 'john', pets: [boingboing, wassup], pet_peeve: regexps) }
+  let(:boingboing) { Pet.new(id: 2, name: 'boingboing', species: 'dog')                              }
+  let(:wassup)     { Pet.new(id: 3, name: 'wassup', species: 'cat')                                  }
+  let(:regexps)    { PetPeeve.new(id: 4, type: 'parsing with regexps')                               }
+end

data/spec/support/models.rb

@@ -0,0 +1,23 @@
+class Pet
+  include Virtus.model
+
+  attribute :id, Integer
+  attribute :name, String
+  attribute :species, String
+end
+
+class PetPeeve
+  include Virtus.model
+
+  attribute :id, Integer
+  attribute :type, String
+end
+
+class Friend
+  include Virtus.model
+
+  attribute :id, Integer
+  attribute :name, String
+  attribute :pets, Array[Pet]
+  attribute :pet_peeve, PetPeeve
+end

data/spec/support/serializers.rb

@@ -0,0 +1,14 @@
+class FriendSerializer < Yaks::Serializer
+  attributes :id, :name
+
+  has_many :pets
+  has_one :pet_peeve
+end
+
+class PetSerializer < Yaks::Serializer
+  attributes :id, :name, :species
+end
+
+class PetPeeveSerializer < Yaks::Serializer
+  attributes :id, :type
+end

data/spec/yaks/json_api_folder_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Yaks
+  describe FoldJsonApi do
+    let(:collection) {
+      SerializableCollection.new(
+        'friends',
+        :id,
+        Hamster.list(
+          SerializableObject.new(
+            Hamster.hash(
+              id: '3',
+              name: 'john'
+            ),
+            Hamster.list(
+              SerializableAssociation.new(
+                SerializableCollection.new(
+                  'pets', :id,
+                  Hamster.list(
+                    SerializableObject.new(Hamster.hash(
+                        id: '3',
+                        pet_name: 'wabi'
+                    ),
+                      Hamster.list
+                    ),
+                    SerializableObject.new(Hamster.hash(
+                        id: '4',
+                        pet_name: 'sabi'
+                    ),
+                      Hamster.list
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    }
+
+    specify do
+      expect( FoldJsonApi.new(collection).fold ).to eq(
+        Hamster.hash(
+          "friends" => Hamster.list(
+            Hamster.hash(
+              "id" => "3",
+              "name" => "john",
+              "links" => Hamster.hash(
+                "pets" => Hamster.list("3", "4")
+              ),
+            )
+          ),
+          "linked" => Hamster.hash(
+            "pets" => Hamster.set(
+              Hamster.hash("pet_name" => "sabi", "id" => "4"),
+              Hamster.hash("pet_name" => "wabi", "id" => "3")
+            )
+          )
+        )
+      )
+    end
+  end
+end

data/spec/yaks/serializer_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Yaks::Serializer do
+  include_context 'fixtures'
+
+  let(:collection) { FriendSerializer.new.serializable_collection [john] }
+
+  it do
+    expect(Yaks::FoldJsonApi.new(collection).fold).to eq({})
+  end
+
+end

data/yaks.gemspec

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/yaks/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'yaks'
+  gem.version     = Yaks::VERSION
+  gem.authors     = [ 'Arne Brasseur' ]
+  gem.email       = [ 'arne@arnebrasseur.net' ]
+  gem.description = 'Serialize to JSON-API and similar'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/plexus/yaks'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec`.split($/)
+  gem.extra_rdoc_files = %w[README.md]
+
+  gem.add_runtime_dependency 'hamster'    , '~> 0.4.3' # 128k , flog: 1851.8
+  gem.add_runtime_dependency 'inflection' , '~> 1.0.0' #  12k , flog:  226.8
+  gem.add_runtime_dependency 'concord'    , '~> 0.1.4' #   8k , flog:   62.3
+
+  # For comparison, ActiveSupport has a flog score of 11134.7
+
+  gem.add_development_dependency 'virtus'
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: yaks
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Arne Brasseur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hamster
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+- !ruby/object:Gem::Dependency
+  name: inflection
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: concord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+- !ruby/object:Gem::Dependency
+  name: virtus
+  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: rspec
+  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'
+description: Serialize to JSON-API and similar
+email:
+- arne@arnebrasseur.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/yaks.rb
+- lib/yaks/dumper.rb
+- lib/yaks/fold_ams_compat.rb
+- lib/yaks/fold_json_api.rb
+- lib/yaks/primitivize.rb
+- lib/yaks/serializable_association.rb
+- lib/yaks/serializable_collection.rb
+- lib/yaks/serializable_object.rb
+- lib/yaks/serializer.rb
+- lib/yaks/serializer/class_methods.rb
+- lib/yaks/util.rb
+- lib/yaks/version.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+- spec/support/models.rb
+- spec/support/serializers.rb
+- spec/yaks/json_api_folder_spec.rb
+- spec/yaks/serializer_spec.rb
+- yaks.gemspec
+homepage: https://github.com/plexus/yaks
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Serialize to JSON-API and similar
+test_files:
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+- spec/support/models.rb
+- spec/support/serializers.rb
+- spec/yaks/json_api_folder_spec.rb
+- spec/yaks/serializer_spec.rb
+has_rdoc: