toast 0.5.2 → 0.6.0

data/app/controller/toast_controller.rb

@@ -6,7 +6,7 @@ class ToastController < ApplicationController
 
       @resource = Toast::Resource.build( params, request )
 
-      render @resource.apply(request.method, request.body.read)
+      render @resource.apply(request.method, request.body.read, request.content_type)
 
     rescue Toast::ResourceNotFound => e
       return head(:not_found)

data/config/routes.rb

@@ -5,17 +5,25 @@ Rails.application.routes.draw do
 
     resource_name = model.to_s.pluralize.underscore
 
-    match("#{model.toast_config.namespace}/#{resource_name}(/:id(/:subresource))" => 'toast#catch_all', 
-          :constraints => { :id => /\d+/ }, 
-          :resource => resource_name,
-          :as => resource_name,
-          :defaults => { :format => 'json' })
-    
-    match("#{model.toast_config.namespace}/#{resource_name}/:subresource" => 'toast#catch_all', 
-          :resource => resource_name,
-          :defaults => { :format => 'json' })
-  end
+    namespaces = []
 
-end
+    # routes must be defined for all defined namespaces of a model
+    model.toast_configs.each do |tc|
+      # once per namespace
+      next if namespaces.include? tc.namespace
+        
+      namespaces << tc.namespace
+      
+      match("#{tc.namespace}/#{resource_name}(/:id(/:subresource))" => 'toast#catch_all',
+            :constraints => { :id => /\d+/ },
+            :resource => resource_name,
+            :as => resource_name,
+            :defaults => { :format => 'json' })
 
+      match("#{tc.namespace}/#{resource_name}/:subresource" => 'toast#catch_all',
+            :resource => resource_name,
+            :defaults => { :format => 'json' })
+    end
+  end
 
+end

data/lib/toast/active_record_extensions.rb

@@ -4,57 +4,64 @@ require 'toast/config_dsl'
 module Toast
   module ActiveRecordExtensions
 
-    # Configuration DSL
-    def resourceful_model &block
-      @toast_config = Toast::ConfigDSL::Base.new(self)
-      Blockenspiel.invoke( block, @toast_config)
+    # Configuration DSL    
+    def acts_as_resource &block
+
+      @toast_configs ||= Array.new 
+      
+      @toast_configs << Toast::ConfigDSL::Base.new(self)
+                  
+      Blockenspiel.invoke( block, @toast_configs.last)
 
       # add class methods
       self.instance_eval do
 
-        cattr_accessor :uri_base
-
         def is_resourceful_model?
           true
         end
 
-        def toast_config
-          @toast_config
+        def toast_configs
+          @toast_configs
+        end
+        
+        # get a config by media type or first one if none matches
+        def toast_config media_type
+          @toast_configs.find do |tc| 
+            tc.media_type == media_type || tc.in_collection.media_type == media_type 
+          end || @toast_configs.first 
         end
       end
 
       # add instance methods
       self.class_eval do
         # Return the path segment of the URI of this record
-        def uri_fullpath
+        def uri_path
           "/" +
-            (self.class.toast_config.namespace ? self.class.toast_config.namespace+"/" : "") +
             self.class.to_s.pluralize.underscore + "/" +
             self.id.to_s
         end
+        
+        # Like ActiveRecord::Base.attributes, but result Hash includes
+        # only attributes from the list _attr_names_ plus the
+        # associations _assoc_names_ as links and the 'self' link
+        def represent attr_names, assoc_names, base_uri
+          props = {}
 
-        # Returns a Hash with all exposed attributes
-        def exposed_attributes options = {}
-          options.reverse_merge! :in_collection => false,
-                                 :with_uri => true
-
-          # attributes
-          exposed_attr =
-            options[:in_collection] ? self.class.toast_config.in_collection.exposed_attributes :
-                                      self.class.toast_config.exposed_attributes
-
-          out = exposed_attr.inject({}) do |acc, attr|
-            acc[attr] = self.send attr
-            acc
+          attr_names.each do |name| 
+            props[name] = self.send(name)
           end
-
-          out
+          
+          assoc_names.each do |name| 
+            props[name] = "#{base_uri}#{self.uri_path}/#{name}"
+          end
+          
+          props["self"] = base_uri + self.uri_path
+          
+          props
         end
       end
     end
 
-    alias acts_as_resource resourceful_model
-
     # defaults for non resourceful-models
     def is_resourceful_model?
       false

data/lib/toast/association.rb

@@ -3,8 +3,9 @@ module Toast
 
     attr_reader :model
 
-    def initialize model, id, subresource_name, format
-      unless model.toast_config.exposed_associations.include? subresource_name
+    def initialize model, id, subresource_name, format, config, assoc_model, assoc_config_in, assoc_config_out
+      
+      unless config.exposed_associations.include? subresource_name
         raise ResourceNotFound
       end
 
@@ -13,28 +14,35 @@ module Toast
       @assoc = subresource_name
       @format = format
       @is_collection = [:has_many, :has_and_belongs_to_many].include? @model.reflect_on_association(@assoc.to_sym).macro
-
-      @associate_model = Resource.get_class_by_resource_name subresource_name
-      @associate_model.uri_base = @model.uri_base
+      @config = config
+      @associate_model = assoc_model
+      @associate_config_in = assoc_config_in
+      @associate_config_out = assoc_config_out
 
     end
 
     def get
       result = @record.send(@assoc)
 
+      raise ResourceNotFound if result.nil?
+
       if result.is_a? Array
         {
           :json => result.map{|r|
-            r.exposed_attributes(:in_collection => true).
-            merge( uri_fields(r, true) )
+            r.represent( @associate_config_out.in_collection.exposed_attributes,
+                         @associate_config_out.in_collection.exposed_associations,
+                         @base_uri )
           },
-          :status => :ok
+          :status => :ok,
+          :content_type => @associate_config_out.in_collection.media_type
         }
       else
         {
-          :json => result.exposed_attributes(:in_collection => true).
-                   merge( uri_fields(result) ),
-          :status => :ok
+          :json =>  result.represent( @associate_config_out.exposed_attributes,
+                                      @associate_config_out.exposed_associations,
+                                      @base_uri ),
+          :status => :ok,
+          :content_type => @associate_config_out.media_type
         }
       end
 
@@ -44,10 +52,10 @@ module Toast
       raise MethodNotAllowed
     end
 
-    def post payload
-      raise MethodNotAllowed unless @model.toast_config.writables.include? @assoc
+    def post payload, media_type
+      raise MethodNotAllowed unless @config.writables.include? @assoc
 
-      if self.media_type != @associate_model.toast_config.media_type
+      if media_type != @associate_config_in.media_type
         raise UnsupportedMediaType
       end
 
@@ -63,18 +71,20 @@ module Toast
 
 
       # silently ignore all exposed readable, but not writable fields
-      (@associate_model.toast_config.readables - @associate_model.toast_config.writables).each do |rof|
+      (@associate_config_in.readables - @associate_config_in.writables).each do |rof|
         payload.delete(rof)
       end
 
-
       begin
         record = @record.send(@assoc).create! payload
 
         {
-          :json => record.exposed_attributes.merge( uri_fields(record) ),
-          :location => self.base_uri + record.uri_fullpath,
-          :status => :created
+          :json => record.represent( @associate_config_out.exposed_attributes,
+                                     @associate_config_out.exposed_associations,
+                                     @base_uri ),
+          :location => self.base_uri + record.uri_path,
+          :status => :created,
+          :content_type => @associate_config_out.media_type
         }
 
       rescue ActiveRecord::RecordInvalid => e

data/lib/toast/collection.rb

@@ -3,11 +3,11 @@ module Toast
 
     attr_reader :model
 
-    def initialize model, subresource_name, params
+    def initialize model, subresource_name, params, config_in, config_out
 
       subresource_name ||= "all"
 
-      unless model.toast_config.collections.include? subresource_name
+      unless config_out.collections.include? subresource_name
         raise ResourceNotFound
       end
 
@@ -15,11 +15,13 @@ module Toast
       @collection = subresource_name
       @params = params
       @format = params[:format]
+      @config_out = config_out
+      @config_in = config_in
     end
 
     def get
 
-      records = if @model.toast_config.pass_params_to.include?(@collection)
+      records = if @config_out.pass_params_to.include?(@collection)
                   @model.send(@collection, @params)
                 else
                   @model.send(@collection)
@@ -34,10 +36,12 @@ module Toast
       when "json"
         {
           :json => records.map{|r|
-            r.exposed_attributes(:in_collection => true).
-            merge( uri_fields(r, true) )
+            r.represent( @config_out.in_collection.exposed_attributes,
+                         @config_out.in_collection.exposed_associations,
+                         @base_uri )
           },
-          :status => :ok
+          :status => :ok,
+          :content_type => @config_out.in_collection.media_type
         }
       else
         raise ResourceNotFound
@@ -48,15 +52,15 @@ module Toast
       raise MethodNotAllowed
     end
 
-    def post payload
-      raise MethodNotAllowed unless @model.toast_config.postable?
+    def post payload, media_type
+      raise MethodNotAllowed unless @config_in.postable?
 
-      if @collection != "all"
-        raise MethodNotAllowed
+      if media_type != @config_in.media_type
+        raise UnsupportedMediaType
       end
 
-      if self.media_type != @model.toast_config.media_type
-        raise UnsupportedMediaType
+      if @collection != "all"
+        raise MethodNotAllowed
       end
 
       begin
@@ -69,7 +73,7 @@ module Toast
       end
 
       # silently ignore all exposed readable, but not writable fields
-      (@model.toast_config.readables - @model.toast_config.writables + ["uri"]).each do |rof|
+      (@config_in.readables - @config_in.writables + ["self"]).each do |rof|
         payload.delete(rof)
       end
 
@@ -77,9 +81,12 @@ module Toast
         record = @model.create! payload
 
         {
-          :json => record.exposed_attributes.merge( uri_fields(record) ),
-          :location => self.base_uri + record.uri_fullpath,
-          :status => :created
+          :json => record.represent( @config_out.exposed_attributes,
+                                     @config_out.exposed_associations,
+                                     @base_uri ),
+          :location => @base_uri + record.uri_path,
+          :status => :created,
+          :content_type => @config_out.media_type
         }
 
       rescue ActiveRecord::RecordInvalid => e

data/lib/toast/config_dsl.rb

@@ -3,7 +3,7 @@ module Toast
 
     class Base
       include Blockenspiel::DSL
-      dsl_attr_accessor :media_type, :has_many, :namespace
+      dsl_attr_accessor :namespace, :media_type
 
       def initialize model
         @model = model
@@ -11,11 +11,11 @@ module Toast
         @writables = []
         @collections = []
         @singles = []
-        @media_type = "application/json"
         @deletable = false
         @postable = false
         @pass_params_to = []
         @in_collection = ConfigDSL::InCollection.new model, self
+        @media_type = "application/json"
       end
 
       def exposed_attributes
@@ -107,11 +107,13 @@ module Toast
     class InCollection
       include Blockenspiel::DSL
 
+      dsl_attr_accessor :media_type
+
       def initialize model, base_config
         @model = model
+        @media_type = "application/json"
         @readables = base_config.readables # must assign a reference
         @writables = base_config.writables # must assign a reference
-        @media_type = "application/json"
       end
 
       def readables= readables
@@ -127,13 +129,23 @@ module Toast
       def writables *arg
         self.writables = 42
       end
-
+      
       def writables= arg
         puts
         puts "Toast Config Warning (#{model.class}): Defining \"writables\" in collection definition has no effect."
         puts
       end
 
+      def namespace *arg
+        self.writables = 42
+      end
+
+      def namespace= arg
+        puts
+        puts "Toast Config Warning (#{model.class}): Defining \"namespace\" in collection definition has no effect."
+        puts
+      end
+
       def exposed_attributes
         assocs = @model.reflect_on_all_associations.map{|a| a.name.to_s}
         (@readables + @writables).uniq.select{|f| !assocs.include?(f)}
@@ -143,6 +155,7 @@ module Toast
         assocs = @model.reflect_on_all_associations.map{|a| a.name.to_s}
         (@readables + @writables).uniq.select{|f| assocs.include?(f)}
       end
+
     end
 
 

data/lib/toast/engine.rb

@@ -6,6 +6,7 @@ require 'toast/record'
 require 'toast/single'
 
 require 'action_dispatch/http/request'
+require 'rack/accept_media_types'
 
 module Toast
   class Engine < Rails::Engine

data/lib/toast/record.rb

@@ -3,22 +3,24 @@ module Toast
 
     attr_reader :model
 
-    def initialize model, id, format
+    def initialize model, id, format, config_in, config_out
       @model = model
       @record = model.find(id) rescue raise(ResourceNotFound.new)
       @format = format
+      @config_in = config_in
+      @config_out = config_out
     end
 
-    def post payload
+    def post payload, media_type
       raise MethodNotAllowed
     end
 
     # get, put, delete, post return a Hash that can be used as
     # argument for ActionController#render
 
-    def put payload
+    def put payload, media_type
 
-      if self.media_type != @model.toast_config.media_type
+      if media_type != @config_in.media_type
         raise UnsupportedMediaType
       end
 
@@ -33,21 +35,24 @@ module Toast
       end
 
       # ignore all exposed readable, but not writable fields
-      (@model.toast_config.readables - @model.toast_config.writables + ["uri"]).each do |rof|
+      (@config_in.readables - @config_in.writables + ["self"]).each do |rof|
         payload.delete(rof)
       end
-
+      
       # set the virtual attributes
-      (payload.keys.to_set - @record.attribute_names.to_set).each do |vattr|
+      (@config_in.writables - @record.attribute_names -  @config_in.exposed_associations).each do |vattr|
         @record.send("#{vattr}=", payload.delete(vattr))
       end
-
+      
       # mass-update for the rest
       @record.update_attributes payload
-      {
-        :json => @record.exposed_attributes.merge( uri_fields(@record) ),
+      {        
+        :json => @record.represent( @config_out.exposed_attributes,
+                                    @config_out.exposed_associations,
+                                    @base_uri ),
         :status => :ok,
-        :location => self.base_uri + @record.uri_fullpath
+        :location => self.base_uri + @record.uri_path,
+        :content_type => @config_out.media_type
       }
     end
 
@@ -60,8 +65,11 @@ module Toast
         }
       when "json"
         {
-          :json => @record.exposed_attributes.merge( uri_fields(@record) ),
-          :status => :ok
+          :json => @record.represent( @config_out.exposed_attributes,
+                                      @config_out.exposed_associations,
+                                      @base_uri ),
+          :status => :ok,
+          :content_type => @config_out.media_type
         }
       else
         raise ResourceNotFound
@@ -69,7 +77,7 @@ module Toast
     end
 
     def delete
-      raise MethodNotAllowed unless @model.toast_config.deletable?
+      raise MethodNotAllowed unless @config_out.deletable?
 
       @record.destroy
       {

data/lib/toast/resource.rb

@@ -5,12 +5,13 @@ module Toast
   class PayloadInvalid < Exception; end
   class PayloadFormatError < Exception; end
   class UnsupportedMediaType < Exception; end
+  class RequestedVersionNotDefined < Exception; end
 
   # Represents a resource. There are following resource types as sub classes:
   # Record, Collection, Association, Single
   class Resource
 
-    attr_accessor :media_type, :base_uri
+    attr_accessor :prefered_media_type, :base_uri, :payload_content_type
 
     def initialize
       raise 'ToastResource#new: use #build to create an instance'
@@ -22,25 +23,56 @@ module Toast
       subresource_name = params[:subresource]
       format = params[:format]
 
-      begin
+      #### Debugging stop
+      # binding.pry if $halt
+      ###
 
+      begin
+        
+        # determine model
         model = get_class_by_resource_name resource_name
-
-        # decide which sub type
-        rsc = if id.nil? and model.toast_config.singles.include?(subresource_name)
-                Toast::Single.new(model, subresource_name, params.clone)
+        
+        # determine config for representation 
+        #  config_in: cosumed representation
+        #  config_out: produced representation
+        config_out = model.toast_config request.accept_media_types.prefered
+        config_in = model.toast_config request.media_type
+
+        #  ... or in case of an association request
+        config_assoc_src = model.toast_config request.headers["Assoc-source-type"]
+        
+        # base URI for returned object
+        base_uri = request.base_url + request.script_name + 
+          (config_out.namespace ? "/" + config_out.namespace : "")
+
+        # decide which sub resource type
+        rsc = if id.nil? and config_out.singles.include?(subresource_name)
+                Toast::Single.new(model, subresource_name, params.clone, config_in, config_out)
               elsif id.nil?
-                Toast::Collection.new(model, subresource_name, params.clone)
+                Toast::Collection.new(model, subresource_name, params.clone, config_in, config_out)
               elsif subresource_name.nil?
-                Toast::Record.new(model, id, format)
-              elsif model.toast_config.exposed_associations.include? subresource_name
-                Toast::Association.new(model, id, subresource_name, format)
+                Toast::Record.new(model, id, format, config_in, config_out)
+              elsif (config_assoc_src && config_assoc_src.exposed_associations.include?(subresource_name))
+                
+                # determine associated model
+                assoc_model = get_class_by_resource_name subresource_name
+                
+                # determine config for representation of assoc. model                
+                assoc_config_out = assoc_model.toast_config request.accept_media_types.prefered
+                assoc_config_in = assoc_model.toast_config request.media_type
+                                
+                # change base URI to associated record
+                base_uri = request.base_url + request.script_name + 
+                  (assoc_config_out.namespace ? "/" + assoc_config_out.namespace : "")
+
+                Toast::Association.new(model, id, subresource_name, format, config_assoc_src, 
+                                       assoc_model, assoc_config_in, assoc_config_out)
               else
                 raise ResourceNotFound
               end
 
-        rsc.media_type = request.media_type
-        rsc.base_uri = request.base_url + request.script_name
+        # set base to be prepended to URIs
+        rsc.base_uri = base_uri
 
         rsc
       rescue NameError
@@ -63,10 +95,10 @@ module Toast
       end
     end
 
-    def apply method, payload
+    def apply method, payload, payload_media_type
       case method
-      when "PUT","POST"
-        self.send(method.downcase, payload)
+      when "PUT","POST"        
+        self.send(method.downcase, payload, payload_media_type)
       when "DELETE","GET"
          self.send(method.downcase)
       else
@@ -83,10 +115,10 @@ module Toast
                         record.class.toast_config.exposed_associations
 
       exposed_assoc.each do |assoc|
-        out[assoc] = "#{self.base_uri}#{record.uri_fullpath}/#{assoc}"
+        out[assoc] = "#{self.base_uri}#{record.uri_path}/#{assoc}"
       end
 
-      out["uri"] = self.base_uri + record.uri_fullpath
+      out["self"] = self.base_uri + record.uri_path
 
       out
     end

data/lib/toast/single.rb

@@ -13,9 +13,11 @@ module Toast
 
     attr_reader :model
 
-    def initialize model, subresource_name, params
+    def initialize model, subresource_name, params, config_in, config_out
+      @config_in = config_in
+      @config_out = config_out
 
-      unless model.toast_config.singles.include? subresource_name
+      unless @config_out.singles.include? subresource_name
         raise ResourceNotFound
       end
 
@@ -23,14 +25,14 @@ module Toast
       @params = params
       @format = params[:format]
 
-      @record = if @model.toast_config.pass_params_to.include?(subresource_name)
+
+      @record = if @config_out.pass_params_to.include?(subresource_name)
                   @model.send(subresource_name, @params)
                 else
                   @model.send(subresource_name)
                 end
-
-      raise ResourceNotFound if @record.nil?
-
+      
+      raise ResourceNotFound if @record.nil?      
     end
 
     def get
@@ -42,7 +44,9 @@ module Toast
         }
       when "json"
         {
-          :json => @record.exposed_attributes.merge( uri_fields(@record) ),
+          :json => @record.represent( @config_out.exposed_attributes,
+                                      @config_out.exposed_associations,
+                                      @base_uri ),
           :status => :ok
         }
       else

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 2
-  version: 0.5.2
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Robert Annies
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-21 00:00:00 +01:00
+date: 2012-05-31 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,6 +31,19 @@ dependencies:
         version: 0.4.2
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rack-accept-media-types
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :runtime
+  version_requirements: *id002
 description: |-
   Toast is an extension to Ruby on Rails that lets you expose any
   ActiveRecord model as a resource according to the REST paradigm. The