toast 0.9.5 → 1.0.0

data/lib/toast/active_record_extensions.rb

@@ -1,85 +0,0 @@
-require 'blockenspiel'
-require 'toast/config_dsl'
-
-module Toast
-  module ActiveRecordExtensions
-
-    # 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
-
-        def is_resourceful_model?
-          true
-        end
-
-        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
-
-        def toast_resource_uri_prefix
-          @toast_resource_uri_prefix ||= self.to_s.pluralize.underscore
-        end
-
-      end
-
-      # add instance methods
-      self.class_eval do
-        # Return the path segment of the URI of this record
-        def uri_path
-          "/" +
-            self.class.toast_resource_uri_prefix + "/" +
-            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, media_type
-          props = {}
-
-          attr_names.each do |name|
-            unless self.respond_to?(name)
-              raise "Toast Error: Connot find instance method '#{self.class}##{name}'"
-            end
-            props[name] = self.send(name)
-          end
-
-          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
-
-    # defaults for non resourceful-models
-    def is_resourceful_model?
-      false
-    end
-    def resourceful_model_options
-      nil
-    end
-  end
-
-  def self.resourceful_models
-    Module.constants.select{ |c| (eval c).respond_to?(:toast_config)}.sort.map{|c| c.constantize}
-  end
-
-end

data/lib/toast/association.rb

@@ -1,219 +0,0 @@
-module Toast
-  class Association < Resource
-
-    attr_reader :model
-
-    def initialize model, id, subresource_name, params, format, config, assoc_model, assoc_config_in, assoc_config_out
-
-      unless config.exposed_associations.include? subresource_name
-        raise ResourceNotFound
-      end
-
-      @model = model
-      @record = model.find(id) rescue raise(ResourceNotFound)
-      @assoc = subresource_name
-      @format = format
-      @is_collection = [:has_many, :has_and_belongs_to_many].include? @model.reflect_on_association(@assoc.to_sym).macro
-      @config = config
-      @associate_model = assoc_model
-      @associate_config_in = assoc_config_in
-      @associate_config_out = assoc_config_out
-      @params = params
-    end
-
-    def get
-
-      unless @record.class.reflect_on_all_associations.detect{|a| a.name.to_s == @assoc}
-        raise "Toast Error: Association '#{@assoc}' not found in model '#{@record.class}'"
-      end
-
-      reflection = @model.reflect_on_association(@assoc.to_sym)
-
-      if reflection.collection?
-
-
-        if(@config.pass_params_to.include?(@assoc) and
-           reflection.options[:extend] and
-           reflection.options[:extend].detect{|e| e.method_defined? :find_by_params} )
-
-          result, pagination_info = paginate_query( @config, @assoc,
-                                                    @record.send(@assoc).find_by_params(@params), @params)
-        else
-
-          result, pagination_info = paginate_query( @config, @assoc,
-                                                    @record.send(@assoc), @params)
-
-        end
-
-        raise ResourceNotFound if result.nil?
-
-        {
-          :json => result.map{|r|
-            r.represent( @associate_config_out.in_collection.exposed_attributes,
-                         @associate_config_out.in_collection.exposed_associations,
-                         @base_uri,
-                         @associate_config_out.media_type )
-          },
-          :status => :ok,
-          :content_type => @associate_config_out.in_collection.media_type,
-          :pagination_info => pagination_info
-        }
-
-      else
-
-        result =
-          if(@config.pass_params_to.include?(@assoc) and
-             reflection.options[:extend] and
-             reflectin.options[:extend].detect{|e| e.method_defined? :find_by_params} )
-            @record.send(@assoc).find_by_params(@params)
-          else
-            @record.send(@assoc)
-          end
-
-        raise ResourceNotFound if result.nil?
-
-        {
-          :json =>  result.represent( @associate_config_out.exposed_attributes,
-                                      @associate_config_out.exposed_associations,
-                                      @base_uri,
-                                      @associate_config_out.media_type),
-          :status => :ok,
-          :content_type => @associate_config_out.media_type
-        }
-      end
-
-
-    rescue ActiveRecord::RecordNotFound
-      raise ResourceNotFound
-    end
-
-    def put payload, media_type
-      raise MethodNotAllowed
-    end
-
-    def post payload, media_type
-      raise MethodNotAllowed unless @config.writables.include? @assoc
-
-      if media_type != @associate_config_in.media_type
-        raise UnsupportedMediaType
-      end
-
-      begin
-        payload = ActiveSupport::JSON.decode(payload).with_indifferent_access
-      rescue
-        raise PayloadFormatError
-      end
-
-      unless payload.is_a? Hash
-        raise PayloadFormatError
-      end
-
-      payload.delete_if {|key,value|
-        !@associate_config_in.writables.include?(key) or
-        @associate_config_in.exposed_associations.include?(key)
-      }
-
-      begin
-        reflection = @model.reflect_on_association(@assoc.to_sym)
-
-        if(@config.pass_params_to.include?(@assoc) and
-           reflection.options[:extend] and
-           reflection.options[:extend].detect{|e| e.method_defined? :create!})
-
-          record = @record.send(@assoc).create! payload, @params
-        else
-          record = @record.send(@assoc).create! payload
-        end
-        {
-          :json => record.represent( @associate_config_out.exposed_attributes,
-                                     @associate_config_out.exposed_associations,
-                                     @base_uri,
-                                     @associate_config_out.media_type),
-          :location => self.base_uri + record.uri_path,
-          :status => :created,
-          :content_type => @associate_config_out.media_type
-        }
-
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved, ActiveRecord::RecordNotUnique => e
-        # model validation failed
-        raise PayloadInvalid.new(e.message)
-      end
-    end
-
-    def delete
-      raise MethodNotAllowed
-    end
-
-    def link link_path_info
-      slash, link_resource_name, link_id = link_path_info.split('/')
-      link_model = Resource.get_class_by_resource_name(link_resource_name)
-      link_record = link_model.find(link_id)
-
-      reflection = @model.reflect_on_association(@assoc.to_sym)
-
-      if(reflection.collection? )
-        # has_many, hbtm
-        if( @config.pass_params_to.include?(@assoc) and
-            reflection.options[:extend] and
-            reflection.options[:extend].detect{|e| e.method_defined? :<<})
-
-          @record.send(@assoc).<<(link_record,@params)
-        else
-          @record.send(@assoc) << link_record
-        end
-      else
-        # has_one, belongs_to
-        @record.send(@assoc+"=",link_record)
-        @record.save
-      end
-
-      {
-        :nothing => true,
-        :status => :no_content
-      }
-
-    rescue ActiveRecord::AssociationTypeMismatch
-      raise Toast::ResourceNotAcceptable
-    rescue ActiveRecord::RecordNotFound
-      raise Toast::ResourceNotFound
-    rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved, ActiveRecord::RecordNotUnique => e
-      # model validation failed (join model used for linking)
-      raise PayloadInvalid.new(e.message)
-    end
-
-    def unlink link_path_info
-
-      slash, link_resource_name, link_id = link_path_info.split('/')
-      link_model = Resource.get_class_by_resource_name(link_resource_name)
-      link_record = link_model.find(link_id)
-
-      reflection = @model.reflect_on_association(@assoc.to_sym)
-
-      if @model.reflect_on_association(@assoc.to_sym).collection?
-        # has_many, hbtm
-        if( @config.pass_params_to.include?(@assoc) and
-            reflection.options[:extend] and
-            reflection.options[:extend].detect{|e| e.method_defined? :delete})
-
-          @record.send(@assoc).delete(link_record,@params)
-        else
-          @record.send(@assoc).delete(link_record) unless link_record.nil?
-        end
-      else
-
-        # has_one, belongs_to
-        if @record.send(@assoc) == link_record
-          @record.send(@assoc+"=",nil)
-          @record.save!
-        end
-      end
-
-      {
-        :nothing => true,
-        :status => :no_content
-      }
-    rescue ActiveRecord::RecordNotFound
-      raise ResourceNotFound
-    end
-  end
-end

data/lib/toast/collection.rb

@@ -1,139 +0,0 @@
-module Toast
-  class Collection < Resource
-
-    attr_reader :model
-
-    def initialize model, subresource_name, params, config_in, config_out
-
-      subresource_name ||= "all"
-
-      unless config_out.collections.include? subresource_name
-        if subresource_name == "all"
-          ToastController.logger.debug "\n\tToast Debug: you may want to declare 'collections :all' in model '#{model}' to enable delivery of the collection '/#{model.to_s.underscore.pluralize}'\n"
-        end
-        raise ResourceNotFound
-      end
-
-      @model = model
-      @collection = subresource_name
-      @params = params
-      @format = params[:format]
-      @config_out = config_out
-      @config_in = config_in
-    end
-
-    def get
-
-      unless @model.respond_to?(@collection)
-        raise "Toast Error: Cannot find class method '#{@collection}' of model '#{@model}', which is configured in 'acts_as_resource > collections'."
-      end
-
-      # FIXME: This is a lot of hallooballoo to check if the #send
-      #        will be successful, but if it's not checked the error
-      #        message is not helpful to find the error.
-
-      if @config_out.pass_params_to.include?(@collection)
-        if @model.method(@collection).arity**2 != 1
-          raise "Toast Error: Class method '#{@collection}' of model '#{@model}' must accept one parameter, as configured by 'acts_as_resource > pass_params_to'."
-        end
-
-        # fetch results
-        #binding.pry if $halt
-        records, pagination_info = paginate_query( @config_out, @collection,
-                                                   @model.send(@collection, @params),
-                                                   @params )
-      else
-
-        if @model.method(@collection).arity > 0
-          raise "Toast Error: Class method '#{@collection}' of model '#{@model}' must not accept any parameter, as configured by 'acts_as_resource'"
-        end
-
-        records, pagination_info = paginate_query( @config_out, @collection,
-                                                   @model.send(@collection=='all'? 'scoped': @collection), # #scoped ?: #all would trigger query too early
-                                                   @params )
-      end
-
-      case @format
-      when "html"
-        {
-          :template => "resources/#{@model.to_s.pluralize.underscore}",
-          :locals => { @model.to_s.pluralize.underscore.to_sym => records,
-                       :pagination_info => pagination_info }
-        }
-      when "json"
-        {
-          :json => records.map{|r|
-            r.represent( @config_out.in_collection.exposed_attributes,
-                         @config_out.in_collection.exposed_associations,
-                         self.base_uri,
-                         @config_out.media_type)
-          },
-          :status => :ok,
-          :content_type => @config_out.in_collection.media_type,
-          :pagination_info => pagination_info
-        }
-      else
-        raise ResourceNotFound
-      end
-    end
-
-    def put
-      raise MethodNotAllowed
-    end
-
-    def post payload, media_type
-      raise MethodNotAllowed unless @config_in.postable?
-
-
-      if media_type != @config_in.media_type
-        raise UnsupportedMediaType
-      end
-
-      begin
-        payload = ActiveSupport::JSON.decode(payload).with_indifferent_access
-      rescue
-        raise PayloadFormatError
-      end
-      unless payload.is_a? Hash
-        raise PayloadFormatError
-      end
-
-      payload.delete_if {|key,value|
-        !@config_in.writables.include?(key) or
-        @config_in.exposed_associations.include?(key)
-      }
-
-      begin
-
-        record = @model.create! payload
-
-        {
-          :json => record.represent( @config_out.exposed_attributes,
-                                     @config_out.exposed_associations,
-                                     self.base_uri,
-                                     @config_out.media_type),
-          :location => self.base_uri + record.uri_path,
-          :status => :created,
-          :content_type => @config_out.media_type
-        }
-
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved, ActiveRecord::RecordNotUnique => e
-        # model validation failed
-        raise PayloadInvalid.new(e.message)
-      end
-    end
-
-    def delete
-      raise MethodNotAllowed
-    end
-
-    def link l
-      raise MethodNotAllowed
-    end
-
-    def unlink l
-      raise MethodNotAllowed
-    end
-
-  end
-end

data/lib/toast/record.rb

@@ -1,123 +0,0 @@
-module Toast
-  class Record < Resource
-
-    attr_reader :model
-
-    def initialize model, id, format, params, config_in, config_out
-      @model = model
-      @record = model.find(id) rescue raise(ResourceNotFound.new)
-      @format = format
-      @config_in = config_in
-      @config_out = config_out
-      @params = params
-    end
-
-    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, media_type
-
-      if media_type != @config_in.media_type
-        raise UnsupportedMediaType
-      end
-
-      begin
-        payload = ActiveSupport::JSON.decode(payload).with_indifferent_access
-      rescue
-        raise PayloadFormatError
-      end
-
-      unless payload.is_a? Hash
-        raise PayloadFormatError
-      end
-
-      # ignore all not explicitly writable attribute
-      payload.delete_if {|key,value|
-        !@config_in.writables.include?(key) or
-        @config_in.exposed_associations.include?(key)
-      }
-
-      # set the virtual attributes
-      (@config_in.writables - @record.attribute_names -  @config_in.exposed_associations).each do |vattr|
-
-        unless (@record.respond_to?("#{vattr}=") && @record.method("#{vattr}=").arity == 1)
-          raise "Toast Error: Connot find setter '#{@record.class}##{vattr}='"
-        end
-
-        @record.send("#{vattr}=", payload.delete(vattr)) if payload.key?(vattr)
-      end
-
-      # mass-update for the rest
-      if @config_in.pass_params_to.include? 'self'
-        # parameter passing
-        @record.update_attributes! payload, @params
-      else
-        @record.update_attributes! payload
-      end
-
-      {
-        :json => @record.represent( @config_out.exposed_attributes,
-                                    @config_out.exposed_associations,
-                                    @base_uri,
-                                    @config_out.media_type ),
-        :status => :ok,
-        :location => self.base_uri + @record.uri_path,
-        :content_type => @config_out.media_type
-      }
-
-    rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved, ActiveRecord::RecordNotUnique => e
-      # model validation failed
-      raise PayloadInvalid.new(e.message)
-    end
-
-    def get
-      case @format
-      when "html", "xml"
-        {
-          :template => "resources/#{model.to_s.underscore}",
-          :locals => { model.to_s.underscore.to_sym => @record } # full record, view should filter
-        }
-      when "json"
-        {
-          :json => @record.represent( @config_out.exposed_attributes,
-                                      @config_out.exposed_associations,
-                                      @base_uri,
-                                      @config_out.media_type),
-          :status => :ok,
-          :content_type => @config_out.media_type
-        }
-      else
-        raise ResourceNotFound
-      end
-    end
-
-    def delete
-      raise MethodNotAllowed unless @config_out.deletable?
-
-      if @record.destroy
-        {
-          :nothing => true,
-          :status => :no_content
-        }
-      else
-        {
-          :nothing => true,
-          :status => :conflict
-        }
-      end
-
-    end
-
-    def link l
-      raise MethodNotAllowed
-    end
-
-    def unlink l
-      raise MethodNotAllowed
-    end
-  end
-end