yaks 0.3.1 → 0.4.0.rc1

data/lib/yaks/mapper/association.rb

@@ -1,48 +1,40 @@
 module Yaks
   class Mapper
     class Association
-      include Equalizer.new(:name, :_mapper, :links)
-      include SharedOptions
+      include Equalizer.new(:name, :mapper, :rel)
 
-      attr_reader :name, :key, :links, :options
-      private :links, :options
+      attr_reader :name, :mapper, :rel, :collection_mapper
 
-      def initialize(name, key, mapper, links, options)
-        @name    = name
-        @key     = key
-        @mapper  = mapper
-        @links   = links
-        @options = options
+      def initialize(name, mapper, rel, collection_mapper)
+        @name, @mapper, @rel, @collection_mapper =
+          name, mapper, rel, collection_mapper
       end
 
-      def self_link
-        links.detect {|link| link.rel? :self }
-      end
-
-      # @param [Symbol] src_type
-      #   The profile type of the resource that contains the association
-      # @param [#call] loader
+      # @param [#call] lookup
       #   A callable that can retrieve an association by its name
-      # @param [Hash] options
       # @return Array[rel, resource]
       #   Returns the rel (registered type or URI) + the associated, mapped resource
-      def map_to_resource_pair(src_type, loader, options)
+      def create_subresource(parent_mapper, lookup, context)
         [
-          options[:rel_registry].lookup(src_type, key),
-          map_resource(loader.(name), options)
+          map_rel(parent_mapper, context.fetch(:policy)),
+          map_resource(lookup[name], context)
         ]
       end
 
-      private
+      def map_rel(parent_mapper, policy)
+        return @rel unless @rel.equal?(Undefined)
+        policy.derive_rel_from_association(parent_mapper, self)
+      end
 
-      def mapper(opts = nil)
-        return _mapper unless _mapper == Undefined
-        opts[:policy].derive_missing_mapper_for_association(self)
+      def association_mapper(policy)
+        return @mapper unless @mapper.equal?(Undefined)
+        policy.derive_mapper_from_association(self)
       end
 
-      def _mapper
-        @mapper
+      # @abstract
+      def map_resource(object, context)
       end
+
     end
   end
 end

data/lib/yaks/mapper/class_methods.rb

@@ -5,8 +5,10 @@ module Yaks
     module ClassMethods
       include Forwardable
       include Util
+      include FP
 
       CONFIG_METHODS = [
+        :type,
         :attributes,
         :link,
         :profile,
@@ -16,7 +18,7 @@ module Yaks
       ]
 
       def config
-        @config ||= Config.new
+        @config ||= Config.new nil, [], [], []
         @config = yield(@config) if block_given?
         @config
       end
@@ -27,7 +29,7 @@ module Yaks
 
       CONFIG_METHODS.each do |method_name|
         define_method method_name do |*args|
-          config &σ(method_name, *args)
+          config &send_with_args(method_name, *args)
         end
       end
 

data/lib/yaks/mapper/config.rb

@@ -1,50 +1,44 @@
 module Yaks
   class Mapper
     class Config
-      include Equalizer.new(:attributes)
+      include Equalizer.new(:type, :attributes, :links, :associations)
 
-      def initialize(attributes = Hamster.list, links = Hamster.list, associations = Hamster.list, profile = nil)
+      attr_reader :links, :associations
+
+      def initialize(type, attributes, links, associations)
+        @type         = type
         @attributes   = attributes
         @links        = links
         @associations = associations
-        @profile      = profile
-        freeze
       end
 
-      def new(updates)
+      def updated(updates)
         self.class.new(
+          updates.fetch(:type)         { type         },
           updates.fetch(:attributes)   { attributes   },
           updates.fetch(:links)        { links        },
-          updates.fetch(:associations) { associations },
-          updates.fetch(:profile)      { profile      },
+          updates.fetch(:associations) { associations }
         )
       end
 
+      def type(type = Undefined)
+        return @type if type.equal?(Undefined)
+        updated(type: type)
+      end
+
       def attributes(*attrs)
         return @attributes if attrs.empty?
-        new(
-          attributes: @attributes + attrs.to_list
+        updated(
+          attributes: @attributes + attrs
         )
       end
 
       def link(rel, template, options = {})
-        new(
-          links: @links.cons(Link.new(rel, template, options))
-        )
-      end
-
-      def profile(type = Undefined)
-        return @profile if type == Undefined
-        new(
-          profile: type
+        updated(
+          links: @links + [Link.new(rel, template, options)]
         )
       end
 
-      # key
-      # embed_style
-      # rel
-      # (profile)
-
       def has_one(name, options = {})
         add_association(HasOne, name, options)
       end
@@ -53,27 +47,18 @@ module Yaks
         add_association(HasMany, name, options)
       end
 
-      def add_association(type, name, options = {})
-        new(
-          associations: @associations.cons(
+      def add_association(type, name, options)
+        updated(
+          associations: @associations + [
             type.new(
               name,
-              options.fetch(:as)     { name },
-              options.fetch(:mapper) { Undefined },
-              options.fetch(:links)  { Yaks::List() },
-              options.reject         {|k,v| [:as, :mapper, :links].include?(k) }
+              options.fetch(:mapper)            { Undefined },
+              options.fetch(:rel)               { Undefined },
+              options.fetch(:collection_mapper) { Undefined },
             )
-          )
+          ]
         )
       end
-
-      def links
-        @links
-      end
-
-      def associations
-        @associations
-      end
     end
   end
 end

data/lib/yaks/mapper/has_many.rb

@@ -1,14 +1,15 @@
 module Yaks
   class Mapper
     class HasMany < Association
-      def map_resource(collection, opts)
-        opts = opts.merge(options)
-        collection_mapper(opts).new(collection, mapper(opts), opts).to_resource
+      def map_resource(collection, context)
+        resource_mapper = association_mapper(context.fetch(:policy))
+        context         = context.merge(resource_mapper: resource_mapper)
+        collection_mapper.new(collection, context).to_resource
       end
 
-      def collection_mapper(opts)
-        opts = opts.merge(options)
-        opts.fetch(:collection_mapper) { CollectionMapper }
+      def collection_mapper
+        return @collection_mapper unless @collection_mapper.equal? Undefined
+        CollectionMapper
       end
     end
   end

data/lib/yaks/mapper/has_one.rb

@@ -1,9 +1,10 @@
 module Yaks
   class Mapper
     class HasOne < Association
-      def map_resource(instance, opts)
-        opts = opts.merge(options)
-        mapper(opts).new(instance, opts).to_resource
+      def map_resource(instance, context)
+        association_mapper(context.fetch(:policy))
+          .new(instance, context)
+          .to_resource
       end
     end
   end

data/lib/yaks/mapper/link.rb

@@ -1,95 +1,92 @@
 module Yaks
   class Mapper
+    # A Yaks::Mapper::Link is part of a mapper's configuration. It captures
+    # what is set through the mapper's class level `#link` function, and is
+    # capable of generating a `Yaks::Resource::Link` for a given mapper
+    # instance (and hence subject).
+    #
+    # @example
+    #   link :self, 'http://api.foo.org/users/{id}', title: ->{ "User #{object.name}" }
+    #   link :profile, 'http://apidocs.foo.org/profiles/users'
+    #   link 'http://apidocs.foo.org/rels/friends', 'http://api.foo.org/users/{id}/friends?page={page}', expand: [:id]
+    #
+    # It takes a relationship identifier, a URI template and an options hash.
+    #
+    # @param rel [Symbol|String] Either a registered relationship type (Symbol)
+    #   or a relationship URI. See [RFC5988 Web Linking](http://tools.ietf.org/html/rfc5988)
+    # @param template [String] A [RFC6570](http://tools.ietf.org/html/rfc6570) URI template
+    # @param template [Symbol] A method name that generates the link. No more expansion is done afterwards
+    # @option expand [Boolean] pass false to pass on the URI template in the response,
+    #   instead of expanding the variables
+    # @option expand [Array[Symbol]] pass a list of variable names to only expand those,
+    #   and return a partially expanded URI template in the response
+    # @option title [String] Give the link a title
+    # @option title [#to_proc] Block that returns the title. If it takes an argument,
+    #   it will receive the mapper instance as argument. Otherwise it is evaluated in the mapper context
     class Link
       extend Forwardable
       include Concord.new(:rel, :template, :options)
       include Util
 
-      def_delegators :uri_template, :expand, :expand_partial
+      def_delegators :uri_template, :expand_partial
 
-      def initialize(rel, template, options = {})
+      def initialize(rel, template, options)
         @rel, @template, @options = rel, template, options
       end
 
       def rel?(rel)
-        self.rel == rel
+        rel().eql? rel
       end
 
-      def expand
-        options.fetch(:expand) { true }
+      # A link is templated if it does not expand, or only partially
+      def templated?
+        !options.fetch(:expand) { true }.equal? true
       end
-      alias expand? expand
 
-      # link 'http://{only}/{certain}/{variables}/{not_expanded}, expand: [:only, :certain, :variables]
-      def expand_partial?
-        expand.respond_to?(:map)
+      # Does this link need expansion, full or partially
+      def expand?
+        options.fetch(:expand) { true }
       end
 
-      def expand_with(lookup)
-        # link :method_that_returns_link
-        return lookup.call(template) if template.is_a? Symbol
-
-        # link 'http://link/{template}', expand: false
-        # link 'http://link/{template}', expand: [:only, :some, :fields]
-        return template unless expand?
+      def template_variables
+        options.fetch(:expand) { uri_template.variables }.map(&:to_sym)
+      end
 
-        if expand_partial?
-          uri_template.expand_partial(expansion_mapping(lookup)).to_s
-        else
-          uri_template.expand(expansion_mapping(lookup))
+      def expansion_mapping(lookup)
+        template_variables.map.with_object({}) do |name, hsh|
+          hsh[name] = lookup[name]
         end
       end
 
+      def uri_template
+        URITemplate.new(template)
+      end
+
       def map_to_resource_link(mapper)
-        make_resource_link(
+        Resource::Link.new(
           rel,
           expand_with(mapper.method(:load_attribute)),
           resource_link_options(mapper)
         )
       end
 
-      def uri_template
-        @uri_template ||= URITemplate.new(template)
-      end
+      def expand_with(lookup)
+        return lookup[template] if template.is_a? Symbol
 
-      def template_variables
-        if expand_partial?
-          uri_template.variables & expand.map(&:to_s)
+        if expand?
+          expand_partial(expansion_mapping(lookup)).to_s
         else
-          uri_template.variables
+          template
         end
       end
 
-      def expansion_mapping(lookup)
-        template_variables.map.with_object({}) do |var, hsh|
-          hsh[var] = lookup.call(var)
-        end
-      end
-
-      # Link properties defined in HAL
-      # href
-      # templated
-      # typed
-      # deprecation
-      # name
-      # profile
-      # title
-      # hreflang
-
       def resource_link_options(mapper)
-        options = self.options
-        options = options.merge(title: resolve_title(options[:title], mapper)) if options.has_key?(:title)
-        options = options.merge( templated: true ) if !expand? || expand_partial?
-        options.reject{|k,v| [:expand].include? k}
+        options = options()
+        options = options.merge(title: Resolve(options[:title], mapper)) if options.key?(:title)
+        options = options.merge(templated: true) if templated?
+        options.reject{|key| key.equal? :expand }
       end
 
-      def resolve_title(title_proc, mapper)
-        Resolve(title_proc, mapper)
-      end
-
-      def make_resource_link(rel, uri, options)
-        Resource::Link.new(rel, uri, options)
-      end
     end
   end
 end

data/lib/yaks/mapper.rb

@@ -3,61 +3,73 @@
 module Yaks
   class Mapper
     extend ClassMethods, Forwardable
-    include Util, MapLinks, SharedOptions
+    include Util, FP
 
     def_delegators 'self.class', :config
     def_delegators :config, :attributes, :links, :associations
 
-    attr_reader :subject, :options
-    private :subject, :options
-    alias object subject
+    attr_reader :object, :context
 
-    def initialize(subject, options = {})
-      @subject = subject
-      @options = YAKS_DEFAULT_OPTIONS.merge(options)
+    def initialize(object, context)
+      @object  = object
+      @context = context
     end
 
-    def to_resource
-      return NullResource.new if subject.nil?
+    def policy
+      context.fetch(:policy)
+    end
+
+    def env
+      context.fetch(:env)
+    end
+
+    def call
+      return NullResource.new if object.nil?
 
       Resource.new(
-        map_attributes,
-        map_links,
-        map_subresources
+        type:         mapper_name,
+        attributes:   map_attributes,
+        links:        map_links,
+        subresources: map_subresources
       )
     end
+    alias to_resource call
 
-    def profile_type
-      config.profile || policy.derive_profile_from_mapper(self)
+    def map_attributes
+      filter(attributes).each_with_object({}) do |attr, memo|
+        memo[attr] = load_attribute(attr)
+      end
     end
 
-    def map_attributes
-      filter(attributes).map &juxt(identity_function, method(:load_attribute))
+    def map_links
+      links.map &send_with_args(:map_to_resource_link, self)
     end
 
     def map_subresources
-      attributes = filter(associations.map(&:name))
-      associations.select{|assoc| attributes.include? assoc.name}.map do |association|
-        association.map_to_resource_pair(
-          profile_type,
+      attributes   = filter(associations.map(&:name))
+      associations = associations().select{|assoc| attributes.include? assoc.name }
+      associations.each_with_object({}) do |association, memo|
+        rel, subresource = association.create_subresource(
+          self,
           method(:load_association),
-          options.merge(parent: subject)
+          context
         )
+        memo[rel] = subresource
       end
     end
 
     def load_attribute(name)
-      respond_to?(name) ? send(name) : subject.send(name)
+      respond_to?(name) ? public_send(name) : object.public_send(name)
     end
     alias load_association load_attribute
 
-    def profile
-      config.profile || policy.derive_missing_profile_from_mapper(self)
-    end
-
     def filter(attrs)
       attrs
     end
 
+    def mapper_name
+      config.type || policy.derive_type_from_mapper_class(self.class)
+    end
+
   end
 end

data/lib/yaks/null_resource.rb

@@ -7,15 +7,15 @@ module Yaks
     end
 
     def attributes
-      Yaks::Hash()
+      {}
     end
 
     def links
-      Yaks::List()
+      []
     end
 
     def subresources
-      Yaks::Hash()
+      {}
     end
 
     def [](*)

data/lib/yaks/primitivize.rb

@@ -1,43 +1,45 @@
 module Yaks
   class Primitivize
-    include Concord.new(:object)
 
-    # TODO Global config, make this extensible in a per-instance way
-    MAPPINGS = {}
+    attr_reader :mappings
 
-    def self.call(object)
-      new(object).call
+    def initialize
+      @mappings = {}
     end
 
-    def self.map(*types, &blk)
-      types.each do |type|
-        MAPPINGS[type] = blk
+    def call(object)
+      mappings.each do |pattern, block|
+        return instance_exec(object, &block) if pattern === object
       end
+      raise "don't know how to turn #{object.class} (#{object.inspect}) into a primitive"
     end
 
-    map String, TrueClass, FalseClass, NilClass, Numeric do
-      object
-    end
-
-    map Symbol do
-      object.to_s
-    end
-
-    map Hash, Hamster::Hash do
-      object.to_enum(:each).with_object({}) do |(key, value), output|
-        output[self.class.(key)] = self.class.(value)
+    def map(*types, &blk)
+      types.each do |type|
+        mappings[type] = blk
       end
     end
 
-    map Enumerable, Hamster::Enumerable do
-      object.map(&self.class.method(:call)).to_a
-    end
-
-    def call
-      MAPPINGS.each do |pattern, block|
-        return instance_eval(&block) if pattern === object
+    def self.create
+      new.tap do |p|
+        p.map String, TrueClass, FalseClass, NilClass, Numeric do |object|
+          object
+        end
+
+        p.map Symbol do |object|
+          object.to_s
+        end
+
+        p.map Hash do |object|
+          object.to_enum(:each).with_object({}) do |(key, value), output|
+            output[call(key)] = call(value)
+          end
+        end
+
+        p.map Enumerable do |object|
+          object.map(&method(:call)).to_a
+        end
       end
-      raise "don't know how to turn #{object.class} (#{object.inspect}) into a primitive"
     end
   end
 end

data/lib/yaks/resource/link.rb

@@ -13,6 +13,10 @@ module Yaks
         options[:name]
       end
 
+      def title
+        options[:title]
+      end
+
       def templated?
         options.fetch(:templated) { false }
       end

data/lib/yaks/resource.rb

@@ -1,20 +1,24 @@
 module Yaks
   class Resource
-    include Equalizer.new(:links, :attributes, :subresources)
-    include Enumerable, LinkLookup
+    include Equalizer.new(:type, :links, :attributes, :subresources)
+    include Enumerable
 
-    attr_reader :attributes, :links, :subresources
+    attr_reader :type, :attributes, :links, :subresources
 
-    def initialize(attributes, links, subresources)
-      @attributes   = Yaks::Hash(attributes)
-      @links        = Yaks::List(links)
-      @subresources = Yaks::Hash(subresources)
+    def initialize(options)
+      @type         = options.fetch(:type, nil)
+      @attributes   = options.fetch(:attributes, {})
+      @links        = options.fetch(:links, [])
+      @subresources = options.fetch(:subresources, {})
     end
 
     def [](attr)
       attributes[attr]
     end
 
+    # def type
+    # end
+
     def each
       return to_enum unless block_given?
       yield self
@@ -23,5 +27,12 @@ module Yaks
     def collection?
       false
     end
+
+    def self_link
+      links.find do |link|
+        link.rel == :self
+      end
+    end
+
   end
 end

data/lib/yaks/serializer/collection_json.rb

@@ -0,0 +1,38 @@
+module Yaks
+  class Serializer
+    class CollectionJson < self
+      Serializer.register self, :collection_json, 'application/vnd.collection+json'
+
+      include FP
+
+      def serialize_resource(resource)
+        result = {
+          version: "1.0",
+          items: serialize_items(resource)
+        }
+        result[:href] = resource.self_link.uri if resource.self_link
+        {collection: result}
+      end
+
+      def serialize_items(resource)
+        resource.map do |item|
+          attrs = item.attributes.map do |name, value|
+            {
+              name: name,
+              value: value
+            }
+          end
+          result = { data: attrs }
+          result[:href] = item.self_link.uri if item.self_link
+          item.links.each do |link|
+            next if link.rel == :self
+            result[:links] ||= []
+            result[:links] << {rel: link.rel, href: link.uri}
+            result[:links].last[:name] = link.name if link.name
+          end
+          result
+        end
+      end
+    end
+  end
+end