yaks 0.0.0 → 0.1.0

data/examples/jsonapi01.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+
+require 'virtus'
+require 'yaks'
+require 'json'
+
+Example = JSON.parse %q<
+    {
+      "posts": [{
+        "id": "1",
+        "title": "Rails is Omakase",
+        "links": {
+          "author": "9",
+          "comments": [ "5", "12", "17", "20" ]
+        }
+      }]
+    }
+>
+
+class Author
+  include Virtus.model
+  attribute :id, String
+end
+
+class Comment
+  include Virtus.model
+  attribute :id, String
+end
+
+class Post
+  include Virtus.model
+  attribute :id, String
+  attribute :title, String
+  attribute :author, Author
+  attribute :comments, Array[Comment]
+end
+
+class AuthorMapper < Yaks::Mapper
+  attributes :id
+end
+
+class CommentMapper < Yaks::Mapper
+  attributes :id
+end
+
+class PostMapper < Yaks::Mapper
+  attributes :id, :title, :links
+
+  has_one :author, mapper: AuthorMapper
+  has_many :comments, mapper: CommentMapper
+end
+
+post = Post.new(
+  id: 1,
+  title: "Rails is Omakase",
+  author: Author.new(id: "9"),
+  comments: [5, 12, 17, 20].map {|id| Comment.new(id: id.to_s)}
+)
+
+resource = PostMapper.new(post).to_resource
+json_api = Yaks::JsonApiSerializer.new(resource).to_json_api
+
+gem 'minitest'
+require 'minitest/autorun'
+
+describe('json-api') {
+  specify { assert_equal Example, json_api }
+}

data/examples/jsonapi02.rb

@@ -0,0 +1,62 @@
+require 'virtus'
+require 'yaks'
+require 'json'
+
+Example = JSON.parse %q<
+    {
+      "posts": [{
+        "id": "1",
+        "title": "Rails is Omakase",
+        "links": {
+          "author": "9"
+        }
+      }],
+      "linked": {
+        "people": [{
+          "id": "9",
+          "name": "@d2h"
+        }]
+      }
+    }
+>
+
+
+class Person
+  include Virtus.model
+  attribute :id, String
+  attribute :name, String
+end
+
+class Post
+  include Virtus.model
+  attribute :id, String
+  attribute :title, String
+  attribute :author, Person
+end
+
+class PersonMapper < Yaks::Mapper
+  attributes :id, :name
+end
+
+class PostMapper < Yaks::Mapper
+  attributes :id, :title, :links
+
+  has_one :author, mapper: PersonMapper
+end
+
+post = Post.new(
+  id: 1,
+  title: "Rails is Omakase",
+  author: Person.new(id: "9", name: "@d2h"),
+)
+
+resource = PostMapper.new(post).to_resource
+
+json_api = Yaks::JsonApiSerializer.new(resource, embed: :resources).to_json_api
+
+gem 'minitest'
+require 'minitest/autorun'
+
+describe('json-api') {
+  specify { assert_equal Example, json_api }
+}

data/examples/jsonapi03.rb

@@ -0,0 +1,86 @@
+require 'virtus'
+require 'yaks'
+require 'json'
+
+Example = JSON.parse %q<
+    {
+      "posts": [{
+        "id": "1",
+        "title": "Rails is Omakase",
+        "links": {
+          "author": "http://example.com/people/1",
+          "comments": "http://example.com/comments/5,12,17,20"
+        }
+      }]
+    }
+>
+
+
+class Person
+  include Virtus.model
+  attribute :id, String
+  attribute :name, String
+end
+
+
+class Comment
+  include Virtus.model
+  attribute :id, String
+end
+
+class Post
+  include Virtus.model
+  attribute :id, String
+  attribute :title, String
+  attribute :author, Person
+  attribute :comments, Array[Comment]
+end
+
+class BaseMapper < Yaks::Mapper
+  link :self, 'http://example.com/{plural_profile_type}/{id}'
+
+  def plural_profile_type
+    pluralize(profile_type.to_s)
+  end
+end
+
+class CollectionMapper < Yaks::CollectionMapper
+  link :self, 'http://example.com/{plural_profile_type}/{id*}'
+
+  def plural_profile_type
+    pluralize(profile_type.to_s)
+  end
+end
+
+class CommentMapper < BaseMapper
+  attributes :id
+end
+
+class PersonMapper < BaseMapper
+  attributes :id, :name
+end
+
+class PostMapper < BaseMapper
+  attributes :id, :title
+
+  has_one :author, mapper: PersonMapper
+  has_many :comments, mapper: CommentMapper, collection_mapper: CollectionMapper
+end
+
+post = Post.new(
+  id: 1,
+  title: "Rails is Omakase",
+  author: Person.new(id: "1", name: "@d2h"),
+  comments: [5, 12, 17, 20].map {|id| Comment.new(id: id.to_s)}
+)
+
+resource = PostMapper.new(post).to_resource
+
+json_api = Yaks::JsonApiSerializer.new(resource, embed: :links).to_json_api
+
+gem 'minitest'
+require 'minitest/autorun'
+
+describe('json-api') {
+  specify { assert_equal Example, json_api }
+}

data/lib/yaks.rb

@@ -1,43 +1,73 @@
+# -*- coding: utf-8 -*-
+
 require 'forwardable'
 
 require 'hamster'
 require 'concord'
 require 'inflection'
+require 'uri_template'
+
+require 'yaks/util'
+require 'yaks/link_lookup'
+require 'yaks/shared_options'
+require 'yaks/primitivize'
+
+require 'yaks/profile_registry'
+require 'yaks/rel_registry'
+require 'yaks/default_policy'
 
 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")
+  YAKS_DEFAULT_OPTIONS = {
+    policy: DefaultPolicy.new,
+    profile_registry: NullProfileRegistry.new,
+    rel_registry: NullRelRegistry.new,
+    singular_links: [:self, :profile]
+  }
+
+  module ClassMethods
+    def Hash(object = nil)
+      return object             if object.is_a? Hamster::Hash
+      return Hamster::EmptyHash if object.nil?
+      Hamster.hash(object)
+    end
+
+    def List(*entries)
+      case entries.size
+      when 0
+        Hamster::EmptyList
+      when 1
+        if entries.first.respond_to? :to_list
+          entries.first.to_list
+        else
+          Hamster.list(*entries.compact)
+        end
       else
-        Object.const_get("#{obj.class.name}Serializer")
+        Hamster.list(*entries)
       end
     end
   end
+  extend ClassMethods
 
-  def List(*args)
-    Hamster.list(*args)
-  end
+end
 
-  def Hash(*args)
-    Hamster.hash(*args)
-  end
 
-  def Set(*args)
-    Hamster.set(*args)
-  end
-end
+require 'yaks/resource'
+require 'yaks/null_resource'
+require 'yaks/resource/link'
+require 'yaks/collection_resource'
+
+require 'yaks/mapper/link'
+require 'yaks/mapper/association'
+require 'yaks/mapper/has_one'
+require 'yaks/mapper/has_many'
+require 'yaks/mapper/config'
+require 'yaks/mapper/class_methods'
+require 'yaks/mapper/map_links'
+require 'yaks/mapper'
+require 'yaks/collection_mapper'
 
-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'
+require 'yaks/hal_serializer'
+require 'yaks/json_api_serializer'

data/lib/yaks/collection_mapper.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+module Yaks
+  class CollectionMapper
+    include Util, Mapper::MapLinks, SharedOptions
+    extend Mapper::ClassMethods
+
+    attr_reader :collection, :resource_mapper, :options
+    private :collection, :resource_mapper, :options
+
+    def_delegators 'self.class', :config
+    def_delegators :config, :links
+
+    def initialize(collection, resource_mapper, options = {})
+      @collection      = collection
+      @resource_mapper = resource_mapper
+      @options         = YAKS_DEFAULT_OPTIONS.merge(options)
+    end
+
+    def to_resource
+      CollectionResource.new(map_links, collection.map {|obj| resource_mapper.new(obj, options).to_resource})
+    end
+
+    def load_attribute(name)
+      respond_to?(name) ? send(name) : collection.map(&name.to_sym)
+    end
+
+    def profile_type
+      resource_mapper.new(nil, options).profile_type
+    end
+
+  end
+end

data/lib/yaks/collection_resource.rb

@@ -0,0 +1,65 @@
+module Yaks
+  # A collection of Resource objects, it has members, and its own set of link
+  # relations like self and profile describing the collection.
+  #
+  # A collection can be the top-level result of an API call, like all posts to
+  # a blog, or a subresource collection, like the comments on a post result.
+  #
+  # Some formats treat everything like a collection, and a single resource as a
+  # collection of one. Others treat every top level response as singular, e.g.
+  # a single "collection of orders". Because of this Resource and
+  # CollectionResource can both be iterated with #each, for the "everything is
+  # a collection crowd", and they both respond to `links`, `attributes` and
+  # `subresources`, so they can both be approached like a singular resource.
+  #
+  # In the second case a collection has a single "subresource", being its
+  # members.
+  class CollectionResource
+    include Equalizer.new(:links, :members)
+    include Enumerable, LinkLookup
+
+    extend Forwardable
+
+    attr_reader :links, :members
+
+    def_delegators :members, :each
+
+    def initialize(links, members)
+      @links   = Yaks::List(links)
+      @members = Yaks::List(members)
+    end
+
+    def attributes
+      Yaks::Hash()
+    end
+
+    # Make a CollectionResource quack like a resource.
+    #
+    # At the moment this is only for HAL, which always assumes
+    # a singular resource at the top level, this way it can treat
+    # whatever it gets as a single resource with links and subresources,
+    # we just push the collection down one level.
+    #
+    # Once inside subresources the HAL serializer does check if a resource
+    # is a collection, since there it does make a distinction, and because
+    # in that case it will iterate with each/map rather than calling subresources,
+    # this doesn't cause infinite recursion. Not very pretty, needs looking at.
+    #
+    # :(
+    def subresources
+      if members && members.any?
+        Yaks::Hash( profile => self )
+      else
+        Yaks::Hash()
+      end
+    end
+
+    def []
+    end
+
+    def collection?
+      true
+    end
+
+  end
+end

data/lib/yaks/default_policy.rb

@@ -0,0 +1,13 @@
+module Yaks
+  class DefaultPolicy
+    include Util
+
+    def derive_profile_from_mapper(mapper)
+      underscore(mapper.class.name.sub(/Mapper$/, '')).to_sym
+    end
+
+    def derive_missing_mapper_for_association(association)
+      Object.const_get("#{camelize(association.name.to_s)}Mapper")
+    end
+  end
+end

data/lib/yaks/hal_serializer.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+# application/hal+json
+#
+# see examples/hal01.rb
+
+module Yaks
+  class HalSerializer < Serializer
+
+    def serialize
+      Primitivize.(serialize_resource(resource))
+    end
+    alias to_hal serialize
+
+    protected
+
+    def serialize_resource(resource)
+      # The HAL spec doesn't say explicitly how to deal missing values,
+      # looking at client behavior (Hyperagent) it seems safer to return an empty
+      # resource.
+      #
+      # return nil if resource.is_a? NullResource
+      result = resource.attributes
+      result = result.put(:_links, serialize_links(resource.links)) unless resource.links.empty?
+      result = result.put(:_embedded, serialize_embedded(resource.subresources)) unless resource.subresources.empty?
+      result
+    end
+
+    def serialize_links(links)
+      links.reduce(Yaks::Hash(), &method(:serialize_link))
+    end
+
+    def serialize_link(memo, link)
+      memo.put(link.rel) {|links|
+        slink = {href: link.uri}.merge(link.options.reject{|k,_| k==:templated})
+        slink.merge!(templated: true) if link.templated?
+        singular?(link.rel) ? slink : Yaks::List(links).cons(slink)
+      }
+    end
+
+    def singular?(rel)
+      options.fetch(:singular_links) { [] }.include?(rel)
+    end
+
+    def serialize_embedded(subresources)
+      subresources.map do |rel, resources|
+        [
+          rel,
+          if resources.collection?
+            resources.map( &method(:serialize_resource) )
+          else
+            serialize_resource(resources)
+          end
+        ]
+      end
+    end
+
+  end
+end