yaks 0.5.0 → 0.6.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35548188d34c9c00d48ed2c575a2be98d424f313
-  data.tar.gz: 203ad17187b3063c9cf04592f026234d6474bc4e
+  metadata.gz: d43a0d564f2fe2f4f074611448fdc3158211aa76
+  data.tar.gz: b15fa02453e1b71c6de06ac9fc157dddf09be27d
 SHA512:
-  metadata.gz: dc6e520c6d8d5d878578481f3ab373867af02a90c3c1ccdf247dba7f3203049b0ba88b4681c6296c726eac52d5d85f30706449be9ae68193680a56ea407050fa
-  data.tar.gz: 465fbab2456ff24a8b1d948eb9cae76133a8d3fdbe2e71a6a54c246fe926693e58296626276560a8e55b99a45e4540345fdaf5b797745791af0ee97f53d4905c
+  metadata.gz: 115a1a00edaf48376c53e47b63ac3c2c96c0eec27fa6cba627c3e455320b5c36a1c6c331f834d08f5718fd991365cfb96ae8c46139df5f17f8cff38326a475f3
+  data.tar.gz: 03103204631478678810e10eccaca2cd66ed9bafbb3b25cf891b8f23e4aab01ed1b2493c918ebf3622f1a20d32d34e42476d8c3ac4b8fdea52752bd557d49066

data/.travis.yml

@@ -1,25 +1,36 @@
 language: ruby
-script: bundle exec $RUN
+script: bundle exec rake $TASK
 rvm:
   - 1.9.3
-  - 2.0.0
-  - 2.1.2
+  - 2.0
+  - 2.1
   - ruby-head
   - rbx-2
   - jruby
   - jruby-head
 env:
-  - RUN=rspec
-  - RUN=rake
+  - TASK=yaks:rspec
+  - TASK=yaks:mutant
+  - TASK=yaks-html:rspec
+  - TASK=yaks-html:mutant
 matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - env: RUN=rake
+    - env: TASK=yaks:mutant
+    - env: TASK=yaks-html:mutant
   exclude:
     - rvm: jruby
-      env: RUN=rake
+      env: TASK=yaks:mutant
+    - rvm: jruby
+      env: TASK=yaks-html:mutant
+
+    - rvm: jruby-head
+      env: TASK=yaks:mutant
     - rvm: jruby-head
-      env: RUN=rake
+      env: TASK=yaks-html:mutant
+
+    - rvm: rbx-2
+      env: TASK=yaks:mutant
     - rvm: rbx-2
-      env: RUN=rake
+      env: TASK=yaks-html:mutant

data/CHANGELOG.md

@@ -23,12 +23,11 @@ end
 
 * Mapping a non-empty collection will try to infer the type, and hence rel of the nested items, based on the first object in the collection. This is only relevant for formats like HAL that don't have a top-level collection representation, and only matters when mapping a collection at the top level, not when mapping a collection from an association.
 
+* Collection+JSON uses a link's "title" attribute to output a link's "name", to better correspond with other formats
+
 * When registering a custom format (Yaks::Format subclass), the signature has changed
 
 ``` ruby
-
-* Collection+JSON uses a link's "title" attribute to output a link's "name", to better correspond with other formats
-
 # 0.4.3
 Format.register self, :collection_json, 'application/vnd.collection+json'
 

data/Gemfile

@@ -1,3 +1,4 @@
 source 'https://rubygems.org'
 
-gemspec
+gemspec path: 'yaks'
+gemspec path: 'yaks-html'

data/Rakefile

@@ -1,64 +1,43 @@
-require 'rubygems/package_task'
 require 'yaks'
-
-spec = Gem::Specification.load(Pathname.glob('*.gemspec').first.to_s)
-Gem::PackageTask.new(spec).define
+require 'yaks-html'
+require 'mutant'
+require 'rubygems/package_task'
+require 'rspec/core/rake_task'
+require 'yard'
 
 desc "Push gem to rubygems.org"
-task :push => :gem do
+task :push => ["yaks:gem", "yaks-html:gem"] do
   sh "git tag v#{Yaks::VERSION}"
   sh "git push --tags"
   sh "gem push pkg/yaks-#{Yaks::VERSION}.gem"
+  sh "gem push pkg/yaks-html-#{Yaks::VERSION}.gem"
 end
 
-require 'mutant'
-task :default => :mutant
+def gem_tasks(gem)
+  namespace gem do
+    spec = Gem::Specification.load("#{gem}/#{gem}.gemspec")
+    Gem::PackageTask.new(spec).define
 
-task :mutant do
-  pattern = ENV.fetch('PATTERN', 'Yaks*')
-  opts    = ENV.fetch('MUTANT_OPTS', '').split(' ')
-  result  = Mutant::CLI.run(%w[-Ilib -ryaks --use rspec --score 100] + opts + [pattern])
-  fail unless result == Mutant::CLI::EXIT_SUCCESS
-end
+    task :mutant do
+      pattern = ENV.fetch('PATTERN', gem == :yaks ? 'Yaks*' : 'Yaks::Format::HTML*')
+      opts    = ENV.fetch('MUTANT_OPTS', '').split(' ')
+      Dir.chdir gem.to_s do
+        result  = Mutant::CLI.run(%W[-Ilib -ryaks --use rspec --score 100] + opts + [pattern])
+        fail unless result == Mutant::CLI::EXIT_SUCCESS
+      end
+    end
 
-task :mutant_chunked do
-  [
-    # Yaks::Util,
-    # Yaks::Primitivize,
-    Yaks::FP,
-    Yaks::Resource,
-    Yaks::NullResource,
-    Yaks::CollectionResource,
-    Yaks::Mapper::Association,
-    Yaks::Mapper::AssociationMapper,
-    Yaks::Mapper::HasMany,
-    Yaks::Mapper::HasOne,
-    Yaks::Mapper::Config,
-    Yaks::Mapper::ClassMethods,
-    Yaks::Mapper::Attribute,
-    Yaks::Format,
-    Yaks::Config::DSL,
-    Yaks::CollectionMapper,
-    Yaks::Mapper::Link,
-    Yaks::Format::JsonApi,
-    Yaks::DefaultPolicy,          # 45/249 (81.93%)
-    Yaks::Format::CollectionJson, # 15/183 (91.80%)
-    Yaks::Format::Hal,            # 17/209 (91.87%)
-    Yaks::Mapper,                 # 12/203 (94.09%)
-    Yaks::Config,                 # 12/263 (95.44%)
-  ].each do |space|
-    puts space
-    ENV['PATTERN'] = "#{space}"
-    Rake::Task["mutant"].execute
-  end
-end
+    RSpec::Core::RakeTask.new(:rspec) do |t, task_args|
+      t.rspec_opts = "-I#{gem}/spec #{gem}/spec"
+    end
 
-begin
-  require 'yard'
 
-  YARD::Rake::YardocTask.new
-rescue LoadError
-  task :yard do
-    $stderr.puts 'In order to run yard, you must: gem install yard'
+    YARD::Rake::YardocTask.new do |t|
+      t.files   = ["#{gem}/lib/**/*.rb" "#{gem}/**/*.md"]
+    end
   end
+
 end
+
+gem_tasks(:yaks)
+gem_tasks(:"yaks-html")

data/yaks/README.md

@@ -0,0 +1,526 @@
+[![Gem Version](https://badge.fury.io/rb/yaks.png)][gem]
+[![Build Status](https://secure.travis-ci.org/plexus/yaks.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/plexus/yaks.png)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/plexus/yaks.png)][codeclimate]
+
+[gem]: https://rubygems.org/gems/yaks
+[travis]: https://travis-ci.org/plexus/yaks
+[gemnasium]: https://gemnasium.com/plexus/yaks
+[codeclimate]: https://codeclimate.com/github/plexus/yaks
+
+# Yak Serializers
+
+### One Stop Hypermedia Shopping ###
+
+*We did the shaving for you*
+
+Yaks is a tool for turning your domain models into Hypermedia resources.
+
+There are at the moment a number of competing media types for building Hypermedia APIs. These all add a layer of semantics on top of a low level serialization format such as JSON or XML. Even though they each have their own design goals, the core features mostly overlap. They typically provide a way to represent resources (entities), and resource collections, consisting of
+
+* Data in key-value format, possibly with composite values
+* Embedded resources
+* Links to related resources
+* Outbound links that have a specific relation to the resource
+
+They might also contain extra control data to specify possible future interactions, not unlike HTML forms.
+
+These different media types for Hypermedia clients and servers base themselves on the same set of internet standards, such as [RFC4288 Media types](http://tools.ietf.org/html/rfc4288), [RFC5988 Web Linking](http://tools.ietf.org/html/rfc5988), [RFC6906 The "profile" link relation](http://tools.ietf.org/search/rfc6906) and [RFC6570 URI Templates](http://tools.ietf.org/html/rfc6570).
+
+## Concepts
+
+Yaks is a processing pipeline, you create and configure the pipeline, then feed data through it.
+
+``` ruby
+yaks = Yaks.new do
+  default_format :hal
+  rel_template 'http://api.example.com/rels/{rel}'
+  format_options(:hal, plural_links: [:copyright])
+  namespace ::MyAPI
+  json_serializer do |data|
+    MultiJson.dump(data)
+  end
+end
+
+yaks.call(data) # => JSON
+```
+
+Yaks performs this serialization in three steps
+
+* It *maps* your data to a `Yaks::Resource`
+* It *formats* the resource to a syntax tree representation
+* It *serializes* to get the final output
+
+For JSON types, the "syntax tree" is just a combination of Ruby primitives, nested arrays and hashes with strings, numbers, booleans, nils.
+
+A Resource is an abstraction shared by all output formats. It can contain key-value attributes, RFC5988 style links, and embedded sub-resources.
+
+To build an API you create a "mapper" for each type of object you want to represent. Yaks takes care of the rest.
+
+For all configuration options see [Yaks::Config::DSL](http://rdoc.info/gems/yaks/frames/Yaks/Config/DSL).
+
+See also the [API Docs on rdoc.info](http://rdoc.info/gems/yaks/frames/file/README.md)
+
+## Mappers
+
+Say your app has a `Post` object for blog posts. To serve posts over your API, define a `PostMapper`
+
+```ruby
+class PostMapper < Yaks::Mapper
+  link :self, '/api/posts/{id}'
+
+  attributes :id, :title
+
+  has_one :author
+  has_many :comments
+end
+```
+
+Configure a Yaks instance and start serializing!
+
+```ruby
+yaks = Yaks.new
+yaks.call(post)
+```
+
+or a bit more elaborate
+
+```ruby
+yaks = Yaks.new do
+  default_format :json_api
+  rel_template 'http://api.example.com/rels/{rel}'
+  format_options(:hal, plural_links: [:copyright])
+end
+
+yaks.call(post, mapper: PostMapper, format: :hal)
+```
+
+### Attributes
+
+Use the `attributes` DSL method to specify which attributes of your model you want to expose, as in the example above. You can override the `load_attribute` method to change how attributes are fetched from the model.
+
+For example, if you are representing data that is stored in a Hash, you could do
+
+```ruby
+class PostHashMapper < Yaks::Mapper
+  attributes :id, :body
+
+  # @param name [Symbol]
+  def load_attribute(name)
+    object[name]
+  end
+end
+```
+
+The default implementation will first try to find a matching method for an attribute on the mapper itself, and will then fall back to calling the actual model. So you can add extra 'virtual' attributes like so :
+
+```ruby
+class CommentMapper < Yaks::Mapper
+  attributes :id, :body, :date
+
+  def date
+    object.created_at.strftime("at %I:%M%p")
+  end
+end
+```
+
+#### Filtering
+
+You can override `#attributes`, or `#associations`.
+
+```ruby
+class SongMapper
+  attributes :title, :duration, :lyrics
+
+  has_one :artist
+  has_one :album
+
+  def minimal?
+    env['HTTP_PREFER'] =~ /minimal/
+  end
+
+  # @return Array<Yaks::Mapper::Attribute>
+  def attributes
+    return super.reject {|attr| attr.name.equal? :lyrics } if minimal?
+    super
+  end
+
+  # @return Array<Yaks::Mapper::Association>
+  def associations
+    return [] if minimal?
+    super
+  end
+end
+```
+
+### Links
+
+You can specify link templates that will be expanded with model attributes. The link relation name should be a registered [IANA link relation](http://www.iana.org/assignments/link-relations/link-relations.xhtml) or a URL. The template syntax follows [RFC6570 URI templates](http://tools.ietf.org/html/rfc6570).
+
+```ruby
+class FooMapper < Yaks::Mapper
+  link :self, '/api/foo/{id}'
+  link 'http://api.foo.com/rels/comments', '/api/foo/{id}/comments'
+end
+```
+
+To prevent a link to be expanded, add `expand: false` as an option. Now the actual template will be rendered in the result, so clients can use it to generate links from.
+
+To partially expand the template, pass an array with field names to expand. e.g.
+
+```ruby
+class ProductMapper < Yaks::Mapper
+  link 'http://api.foo.com/rels/line_item', '/api/line_items?product_id={product_id}&quantity={quantity}', expand: [:product_id]
+end
+
+# "_links": {
+#    "http://api.foo.com/rels/line_item": {
+#      "href": "/api/line_items?product_id=273&quantity={quantity}",
+#      "templated": true
+#    }
+# }
+
+```
+
+You can pass a symbol instead of a template, in that case the symbol will be used as a method name on the object to retrieve the link. You can override this behavior just like with attributes.
+
+```ruby
+class FooMapper < Yaks::Mapper
+  link 'http://api.foo.com/rels/go_home', :home_url
+  # by default calls object.home_url
+
+  def home_url
+    object.setting('home_url')
+  end
+end
+```
+
+### Associations
+
+Use `has_one` for an association that returns a single object, or `has_many` for embedding a collection.
+
+Options
+
+* `:mapper` : Use a specific for each instance, will be derived from the class name if omitted (see Policy vs Configuration)
+* `:collection_mapper` : For mapping the collection as a whole, this defaults to Yaks::CollectionMapper, but you can subclass it for example to add links or attributes on the collection itself
+* `:rel` : Set the relation (symbol or URI) this association has with the object. Will be derived from the association name and the configured rel_template if ommitted
+* `:link_if`: Conditionally render the association as a link. A `:href` option is required
+
+```ruby
+class ShowMapper < Yaks::Mapper
+  has_many :events, href: '/show/{id}/events', link_if: ->{ events.count > 50 }
+end
+```
+
+## Calling Yaks
+
+Once you have a Yaks instance, you can call it with `call`
+(`serialize` also works but might be deprecated in the future.) Pass
+it the data to be serialized, plus options.
+
+* `:env` a Rack environment, see next section
+* `:format` the format to be used, e.g. `:json_api`. Note that if the Rack env contains an `Accept` header which resolves to a recognized format, then the header takes precedence
+* `:mapper` the mapper to be used. Will be inferred if omitted
+* `:item_mapper` When rendering a collection, the mapper to be used for each item in the collection. Will be inferred from the class of the first item in the collection if omitted.
+
+### Rack env
+
+When serializing, Yaks lets you pass in an `env` hash, which will be made available to all mappers.
+
+```ruby
+yaks = Yaks.new
+yaks.call(foo, env: my_env)
+
+class FooMapper
+  attributes :bar
+
+  def bar
+    if env['something']
+      #...
+    end
+  end
+end
+```
+
+The env hash will be available to all mappers, so you can use this to pass around context. In particular context related to the current HTTP request, e.g. the current logged in user, which is why the recommended use is to pass in the Rack environment.
+
+If `env` contains a `HTTP_ACCEPT` key (Rack's way of representing the `Accept` header), Yaks will return the format that most closely matches what was requested.
+
+## Namespace
+
+Yaks by default will find your mappers for you if they follow the naming convention of appending 'Mapper' to the model class name. This (and all other "conventions") can be easily redefined though, see below. If you have your mappers inside a module, use `namespace`.
+
+```ruby
+module API
+  module Mappers
+    class PostMapper < Yaks::Mapper
+      #...
+    end
+  end
+end
+
+yaks = Yaks.new do
+  namespace API::Mappers
+end
+```
+
+If your namespace contains a `CollectionMapper`, Yaks will use that instead of `Yaks::CollectionMapper`, e.g.
+
+```ruby
+module API
+  module Mappers
+    class CollectionMapper < Yaks::CollectionMapper
+      link :profile, 'http://api.example.com/profiles/collection'
+    end
+  end
+end
+```
+
+You can also have collection mappers based on the type of members the collection holds, e.g.
+
+```ruby
+module API
+  module Mappers
+    class LineItemCollectionMapper < Yaks::CollectionMapper
+      link :profile, 'http://api.example.com/profiles/line_items'
+      attributes :total
+
+      def total
+        collection.inject(0) do |memo, line_item|
+          memo + line_item.price * line_item.quantity
+        end
+      end
+    end
+  end
+end
+```
+
+Yaks will automatically detect and use this collection when serializing an array of `LineItem` objects.
+
+
+## Custom attribute/link/subresource handling
+
+When inheriting from `Yaks::Mapper`, you can override `map_attributes`, `map_links` and `map_resources` to skip (or augment) above methods, and instead implement your own custom mechanism. These methods take a `Yaks::Resource` instance, and should return an updated resource. They should not alter the resource instance in-place. For example
+
+```ruby
+class ErrorMapper < Yaks::Mapper
+  link :profile, '/api/error'
+
+  def map_attributes(resource)
+    attrs = {
+      http_code: 500,
+      message: object.to_s,
+      type: object.class.name.underscore
+    }
+
+    case object
+    when AllocationException
+      attrs[:http_code] = 422
+    when ActiveRecord::RecordNotFound
+      attrs[:http_code] = 404
+      attrs[:type] = "record_not_found"
+    end
+
+    resource.update_attributes(attrs)
+  end
+end
+```
+
+## Resources and Serializers
+
+Yaks uses an intermediate "Resource" representation to support multiple output formats. A mapper turns a domain model into a `Yaks::Resource`. A serializer (e.g. `Yaks::Serializer::Hal`) takes the resource and outputs the structure of the target format.
+
+Since version 0.4 the recommended API is through `Yaks.new {...}.serialize`. This will give you back a composite value consisting of primitives that have a mapping to JSON, so you can use your favorite JSON encoder to turn this into a character stream.
+
+```ruby
+my_yaks = Yaks.new
+hal = my_yaks.call(model)
+puts JSON.dump(hal)
+```
+
+There are at least a handful of JSON libraries and implementations for Ruby out there, with different trade-offs. Yaks does not impose an opinion on which one to use
+
+### HAL
+
+This is the default. In HAL one decides when building an API which links can only be singular (e.g. self), and which are always represented as an array. Yaks defaults to singular as I've found it to be the most common case. If you want specific links to be plural, then configure their rel href as such.
+
+```ruby
+hal = Yaks.new do
+  format_options :hal, plural_links: ['http://api.example.com/rels/foo']
+end
+```
+
+CURIEs are not explicitly supported (yet), but it's possible to use them with some effort, see `examples/hal01.rb` for an example.
+
+The line between a singular resource and a collection is fuzzy in HAL. To stick close to the spec you're best to create your own singular types that represent collections, rather than rendering a top level CollectionResource.
+
+### JSON-API
+
+```ruby
+default_format :json_api
+```
+
+JSON-API has no concept of outbound links, so these will not be rendered. Instead the key will be inferred from the mapper class name by default. This can be changed per mapper:
+
+```ruby
+class AnimalMapper
+  key :pet
+end
+```
+
+Or the policy can be overridden:
+
+```ruby
+yaks = Yaks.new do
+  derive_type_from_mapper_class do |mapper_class|
+    piglatinize(mapper_class.to_s.sub(/Mapper$/, ''))
+  end
+end
+```
+
+### Collection+JSON
+
+```ruby
+default_format :collection_json
+```
+
+Subresources aren't mapped because Collection+JSON doesn't really have that concept, and the other way around templates and queries don't exist (yet) in Yaks.
+
+### More formats
+
+Are planned... at the moment HAL is the only format I actually use, so it's the one that's best supported. Adding formats that follow the resource=(attributes, links, subresources) structure or a subset thereof is straightforward. More features, e.g. forms/actions such as used in Mason might be added in the future.
+
+## Hooks
+
+It is possible to hook into the Yaks pipeline to perform extra processing steps before, after, or around each step. It also possible to skip a step.
+
+``` ruby
+yaks = Yaks.new do
+  # Automatically give every resource a self link
+  after :map, :add_self_link do |resource|
+    resource.add_link(Yaks::Resource::Link.new(:self, "/#{resource.type}/#{resource.attributes[:id]}"))
+  end
+
+  # Skip serialization, so Ruby primitives come back instead of JSON
+  # This was the default before versions < 0.5.0
+  skip :serialize
+end
+```
+
+## Policy over Configuration
+
+It's an old adage in the Ruby/Rails world to have "Convention over Configuration", mostly to derive values that were not given explicitly. Typically based on things having similar names and a 1-1 derivable relationship.
+
+This saves a lot of typing, but for the uninitiated it can also create confusion, the implicitness makes it hard to follow what's going on.
+
+What's worse, is that often the Configuration part is skipped entirely, making it very hard to deviate from the Golden Standard.
+
+There is another old adage, "Policy vs Mechanism". Implement the mechanisms, but don't dictate the policy.
+
+In Yaks whenever missing values need to be inferred, like finding an unspecified mapper for a relation, this is handled by a policy object. The default is `Yaks::DefaultPolicy`, you can go there to find all the rules of inference. Single rules of inference can be redefined directly in the Yaks configuration:
+
+```ruby
+yaks = Yaks.new do
+  derive_mapper_from_object do |model|
+    # ...
+  end
+
+  derive_type_from_mapper_class do |mapper_class|
+    # ...
+  end
+
+  derive_mapper_from_association do |association|
+    # ...
+  end
+
+  derive_rel_from_association do |mapper, association|
+    # ...
+  end
+end
+```
+
+You can also subclass or create from scratch your own policy class
+
+```ruby
+class MyPolicy < DefaultPolicy
+  #...
+end
+
+yaks = Yaks.new do
+  policy MyPolicy
+end
+```
+
+## Primitives
+
+For JSON based formats, the "syntax tree" is merely a structure of Ruby primitives that have a JSON equivalent. If your mappers return non-primitive attribute values, you can define how they should be converted. For example, JSON has no notion of dates. If your mappers return these types as attributes, then Yaks needs to know how to turn these into primitives. To add extra types, use `map_to_primitive`
+
+```ruby
+Yaks.new do
+  map_to_primitive Date, Time, DateTime do |date|
+    date.iso8601
+  end
+end
+```
+
+This can also be used to transform alternative data structures, like those from Hamster, into Ruby arrays and hashes. Use `call()` to recursively turn things into primitives.
+
+```ruby
+Yaks.new do
+  map_to_primitive Hamster::Vector, Hamster::List do |list|
+    list.map do |item|
+      call(item)
+    end
+  end
+end
+```
+
+Yaks by default "primitivizes" symbols (as strings), and classes that include Enumerable (as arrays).
+
+## Real World Usage
+
+Yaks is used in production by [Ticketsolve](http://www.ticketsolve.com/). You can find an example API endpoint [here](http://leicestersquaretheatre.ticketsolve.com/api).
+
+Get in touch if you like to see your name and API here.
+
+## Demo
+
+You can find an example app at [Yakports](https://github.com/plexus/yakports), or browse the HAL api directly using the [HAL browser](http://yaks-airports.herokuapp.com/browser.html).
+
+## Acknowledgment
+
+The mapper syntax is largely borrowed from ActiveModel::Serializers, which in turn closely mimics the syntax of ActiveRecord models. It's a great concise syntax that still offers plenty of flexibility, so to not reinvent the wheel I've stuck to the existing syntax as far as practical, although there are several extensions and deviations.
+
+## Lightweight
+
+Yaks is a lean library. It only depends on a few other tiny libraries (inflection, concord, uri_template). It has no core extensions (monkey patches). There is deliberately no built-in "integration" with existing frameworks, since the API is simply enough. You just call it.
+
+If this approach sounds appealing, have a look at [microrb.com](http://microrb.com/).
+
+## Is it any good
+
+[Yes](https://news.ycombinator.com/item?id=3067434)
+
+## How to contribute
+
+Run the tests, the examples, try it with your own stuff and leave your impressions in the issues. Or discuss on [API-craft](https://groups.google.com/d/forum/api-craft).
+
+To fix a bug
+
+1. Fork the repo
+2. Fix the bug, add tests for it
+3. Push it to a named branch
+4. Add a PR
+
+To add a feature
+
+1. Open an issue as soon as possible to gather feedback
+2. Same as above, fork, push to named branch, make a pull-request
+
+Yaks uses [Mutation Testing](https://github.com/mbj/mutant). Run `rake mutant` and look for percentage coverage. In general this should only go up.
+
+## License
+
+MIT License (Expat License), see [LICENSE](./LICENSE)
+
+![](shaved_yak.gif)