toast 0.9.5 → 1.0.0

data/lib/toast/collection_request.rb

@@ -0,0 +1,161 @@
+require 'toast/request_helpers'
+require 'toast/http_range'
+
+class Toast::CollectionRequest
+  include Toast::RequestHelpers
+  include Toast::Errors
+
+  def initialize config, base_config, auth, request
+    @config          = config
+    @base_config     = base_config
+    @base_uri        = base_uri(request)
+    @verb            = request.request_method.downcase
+    @requested_range = Toast::HttpRange.new(request.env['HTTP_RANGE'])
+    @selected_attributes = request.query_parameters.delete(:toast_select).try(:split,',')
+    @uri_params      = request.query_parameters
+    @auth            = auth
+    @request         = request
+  end
+
+  def respond
+    if @verb.in? %w(get post)
+      self.send(@verb)
+    else
+      response :method_not_allowed,
+               headers: {'Allow' => allowed_methods(@base_config)},
+               msg: "method #{@verb.upcase} not supported for collection URIs"
+    end
+  end
+
+  private
+  def get
+    if @config.via_get.nil?
+      # not declared
+      response :method_not_allowed,
+               headers: {'Allow' => allowed_methods(@config)},
+               msg: "GET not configured"
+    else
+      begin
+
+        range_start = @requested_range.start
+        window      = if (@requested_range.size.nil? || @requested_range.size > @config.max_window)
+                        @config.max_window
+                      else
+                        @requested_range.size
+                      end
+
+        relation    = call_handler(@config.via_get.handler, @uri_params)
+        call_allow(@config.via_get.permissions,
+                    @auth, relation, @uri_params)
+
+        if relation.is_a?(ActiveRecord::Relation) and
+          relation.model == @config.base_model_class
+
+          # count = relation.count doesn't always work
+          # fix problematic select extensions for counting (-> { select(...) })
+          # this fails if the where clause depends on the the extended select
+          count = relation.count_by_sql relation.to_sql.sub(/SELECT.+FROM/,'SELECT COUNT(*) FROM')
+          headers = {"Content-Type" => @config.media_type}
+
+          if count > 0
+            range_end = if (range_start + window - 1) > (count - 1) # behind last
+                        count - 1
+                      else
+                        (range_start + window - 1)
+                      end
+
+            headers[ "Content-Range"] = "items=#{range_start}-#{range_end}/#{count}"
+          end
+
+          response :ok,
+                   headers: headers,
+                   body: represent(relation.limit(window).offset(range_start), @base_config),
+                   msg: "sent #{count} of #{@config.mode_class}"
+
+        else
+          # wrong class/model_class
+          response :internal_server_error,
+                   msg: "collection method returned #{relation.class}, expected ActiveRecord::Relation of #{@config.base_model_class}"
+        end
+
+
+      rescue NotAllowed => error
+        return response :unauthorized,
+                        msg: "not authorized by allow block in: #{error.source_location}"
+
+      rescue BadRequest => error
+        response :bad_request, msg: "`#{error.message}' in: #{error.source_location}"
+
+      rescue HandlerError => error
+        return response :internal_server_error,
+                        msg: "exception raised in via_get handler: `#{error.orig_error.message}' in #{error.source_location}"
+      rescue AllowError => error
+        return response :internal_server_error,
+                        msg: "exception raised in allow block: `#{error.orig_error.message}' in #{error.source_location}"
+      rescue => error
+        response :internal_server_error,
+                 msg: "exception from via_get handler in: #{error.backtrace.first.sub(Rails.root.to_s+'/', '')}: #{error.message}"
+      end
+    end
+  end
+
+  def post
+    if @config.via_post.nil?
+      # not declared
+      response :method_not_allowed,
+               headers: {'Allow' => allowed_methods(@config)},
+               msg: "POST not configured"
+    else
+      begin
+        payload  = JSON.parse(@request.body.read)
+
+        call_allow(@config.via_post.permissions,
+                   @auth, nil, @uri_params)
+
+        # remove all attributes not in writables from payload
+        payload.delete_if do |attr,val|
+          unless attr.to_sym.in?(@base_config.writables)
+            Toast.logger.warn "<POST #{@request.fullpath}> received attribute `#{attr}' is not writable or unknown"
+            true
+          end
+        end
+
+        new_instance = call_handler(@config.via_post.handler, payload, @uri_params)
+
+        if new_instance.persisted?
+          response :created,
+                   headers: {"Content-Type" => @config.media_type},
+                   msg: "created #{new_instance.class}##{new_instance.id}",
+                   body: represent(new_instance, @base_config)
+        else
+          message = new_instance.errors.count > 0 ?
+                      ": " + new_instance.errors.full_messages.join(',') : ''
+
+          response :conflict,
+                   msg: "creation of #{new_instance.class} aborted#{message}"
+        end
+
+      rescue JSON::ParserError => error
+        return response :internal_server_error, msg: "expect JSON body"
+
+      rescue NotAllowed => error
+        return response :unauthorized,
+                        msg: "not authorized by allow block in: #{error.source_location}"
+
+      rescue BadRequest => error
+        response :bad_request, msg: "`#{error.message}' in: #{error.source_location}"
+
+      rescue HandlerError => error
+        return response :internal_server_error,
+                        msg: "exception raised in via_post handler: `#{error.orig_error.message}' in #{error.source_location}"
+      rescue AllowError => error
+        return response :internal_server_error,
+                        msg: "exception raised in allow block: `#{error.orig_error.message}' in #{error.source_location}"
+      rescue => error
+        response :internal_server_error,
+                 msg: "exception from via_post handler in: #{error.backtrace.first.sub(Rails.root.to_s+'/', '')}: #{error.message}"
+
+      end
+    end
+  end
+end

data/lib/toast/config_dsl/association.rb

@@ -0,0 +1,72 @@
+require 'toast/config_dsl/via_verb.rb'
+require 'toast/config_dsl/default_handlers.rb'
+
+class Toast::ConfigDSL::Association
+  include Toast::ConfigDSL::Common
+  include Toast::ConfigDSL::DefaultHandlers
+
+  def via_get &block
+    stack_push 'via_get' do
+      @config_data.via_get =
+        OpenStruct.new(permissions: [],
+                       handler: (@config_data.singular ?
+                                   singular_assoc_get_handler(@config_data.assoc_name) :
+                                   plural_assoc_get_handler(@config_data.assoc_name)))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_get).instance_eval &block
+
+
+    end
+  end
+
+  def via_post &block
+    stack_push 'via_post' do
+      if @config_data.singular
+        raise_config_error "`via_post' is not allowed for singular associations"
+      end
+
+      @config_data.via_post = OpenStruct.new(permissions: [],
+                                             handler: plural_assoc_post_handler(@config_data.assoc_name))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_post).instance_eval &block
+
+
+    end
+  end
+
+  def via_link &block
+    stack_push 'via_link' do
+      @config_data.via_link = OpenStruct.new(permissions: [],
+                                             handler: (@config_data.singular ?
+                                                         singular_assoc_link_handler(@config_data.assoc_name) :
+                                                         plural_assoc_link_handler(@config_data.assoc_name)))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_link).instance_eval &block
+
+    end
+  end
+
+  def via_unlink &block
+    stack_push 'via_unlink' do
+      @config_data.via_unlink = OpenStruct.new(permissions: [],
+                                               handler:  (@config_data.singular ?
+                                                            singular_assoc_unlink_handler(@config_data.assoc_name) :
+                                                            plural_assoc_unlink_handler(@config_data.assoc_name)))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_unlink).instance_eval &block
+
+    end
+  end
+
+  def max_window size
+    stack_push 'max_window' do
+      if size.is_a?(Fixnum) and size > 0
+        @config_data.max_window = size
+      elsif size == :unlimited
+        @config_data.max_window = 10**6 # yes that's inifinity 
+      else
+        raise_config_error 'max_window must a positive integer or :unlimited'
+      end
+    end
+  end
+end

data/lib/toast/config_dsl/base.rb

@@ -0,0 +1,50 @@
+require 'toast/config_dsl/expose'
+
+class Toast::ConfigDSL::Base
+  include Toast::ConfigDSL::Common
+
+  def expose model_class, as: 'application/json', under: '', &block
+
+    stack_push "expose(#{model_class})" do
+
+      begin
+        unless model_class.new.is_a?(ActiveRecord::Base)
+          raise_config_error 'Directive requires an ActiveRecord::Base descendant.'
+        end
+      rescue ActiveRecord::StatementInvalid => error
+        # may be raised when tables are not setup yet during database setup
+        raise_config_error error.message
+      end
+
+      unless block_given?
+        raise_config_error 'Block expected.'
+      end
+
+      config_data = OpenStruct.new
+
+      config_data.instance_eval do
+        self.source_location = block.source_location.first
+
+        self.model_class     = model_class
+        self.media_type      = as
+        self.url_path_prefix = under.split('/').delete_if(&:blank?)
+
+        # defaults
+        self.readables    = []
+        self.writables    = []
+        self.collections  = {}
+        self.singles      = {}
+        self.associations = {}
+      end
+
+      if Toast.expositions.detect{|exp| exp.model_class == config_data.model_class}
+        raise_config_error "Model class #{exp.model_class} has already another configuration."
+      end
+
+      Toast.expositions << config_data
+
+      # evaluate expose block
+      Toast::ConfigDSL::Expose.new(config_data).instance_eval &block
+    end
+  end
+end

data/lib/toast/config_dsl/collection.rb

@@ -0,0 +1,45 @@
+require 'toast/config_dsl/via_verb.rb'
+require 'toast/config_dsl/default_handlers.rb'
+
+class Toast::ConfigDSL::Collection
+  include Toast::ConfigDSL::Common
+  include Toast::ConfigDSL::DefaultHandlers
+
+  def via_get &block
+    stack_push 'via_get' do
+      @config_data.via_get =
+        OpenStruct.new(permissions: [],
+                       handler: collection_get_handler(@config_data.base_model_class,
+                                                       @config_data.collection_name))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_get).instance_eval &block
+
+    end
+  end
+
+  def via_post &block
+    stack_push 'via_post' do
+      unless @config_data.collection_name == :all
+        raise_config_error "POST is supported for the `all' collection only"
+      end
+
+      @config_data.via_post = OpenStruct.new(permissions: [],
+                                             handler: collection_post_handler(@config_data.base_model_class))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_post).instance_eval &block
+
+    end
+  end
+
+  def max_window size
+    stack_push 'max_window' do
+      if size.is_a?(Integer) and size > 0
+        @config_data.max_window = size
+      elsif size == :unlimited
+        @config_data.max_window = 10**6 # yes that's inifinity 
+      else
+        raise_config_error 'max_window must a positive integer or :unlimited'
+      end
+    end
+  end
+end

data/lib/toast/config_dsl/common.rb

@@ -0,0 +1,38 @@
+module Toast::ConfigDSL::Common
+  def initialize config_data=nil
+    @config_data = config_data
+  end
+
+  def method_missing method, *args
+    raise_config_error "Unknown directive: `#{method}'"
+  end
+
+  def check_symbol_list list
+    unless list.is_a?(Array) and list.all?{|x| x.is_a? Symbol}
+      raise_config_error "Directive requires a list of symbols.\n"+
+                         "  #{list.map{|x| x.inspect}.join(', ')} ?"
+    end
+  end
+
+  def raise_config_error message=''
+    match = caller.grep(/#{Toast::ConfigDSL.cfg_name}/).first
+
+    file_line = if match.nil?
+                  Toast::ConfigDSL.cfg_name
+                else
+                  match.split(':in').first
+                end
+
+    message += "\n              directive: /#{Toast::ConfigDSL.stack.join('/')}"
+    message += "\n              in file  : #{file_line}"
+
+    Toast.raise_config_error message
+  end
+
+  # ... to not forget to pop use:
+  def stack_push level, &block
+    Toast::ConfigDSL.stack << level
+    yield
+    Toast::ConfigDSL.stack.pop
+  end
+end

data/lib/toast/config_dsl/default_handlers.rb

@@ -0,0 +1,83 @@
+module Toast::ConfigDSL::DefaultHandlers
+  def plural_assoc_get_handler assoc_name
+    lambda do |source, uri_params|
+      source.send(assoc_name)
+    end
+  end
+
+  def singular_assoc_get_handler assoc_name
+    lambda do |source, uri_params|
+      source.send(assoc_name)
+    end
+  end
+
+  def single_get_handler model_class, single_name
+    lambda do |uri_params|
+      model_class.send(single_name)
+    end
+  end
+
+  def collection_get_handler model_class, coll_name
+    lambda do |uri_params|
+      model_class.send(coll_name)
+    end
+  end
+
+  def canonical_get_handler
+    lambda do |model, uri_params|
+      model
+    end
+  end
+
+  def canonical_patch_handler
+    lambda do |model, payload, uri_params|
+      model.update payload
+    end
+  end
+
+  def collection_post_handler model_class
+    lambda do |payload, uri_params|
+      model_class.create payload
+    end
+  end
+
+  def plural_assoc_post_handler assoc_name
+    lambda do |source, payload, uri_params|
+      source.send(assoc_name).create payload
+    end
+  end
+
+  def canonical_delete_handler
+    lambda do |model, uri_params|
+      model.destroy
+    end
+  end
+
+  def singular_assoc_link_handler assoc_name
+    lambda do |source, target, uri_params|
+      source.send("#{assoc_name}=", target)
+      source.save
+    end
+  end
+
+  def plural_assoc_link_handler assoc_name
+    lambda do |source, target, uri_params|
+      source.send(assoc_name) << target
+    end
+  end
+
+  def singular_assoc_unlink_handler assoc_name
+    lambda do |source, target, uri_params|
+      if source.send(assoc_name) == target
+        source.send("#{assoc_name}=", nil)
+        source.save
+      end
+    end
+  end
+
+  def plural_assoc_unlink_handler name
+    lambda do |source, target, uri_params|
+      source.send(name).delete(target)
+    end
+  end
+end

data/lib/toast/config_dsl/expose.rb

@@ -0,0 +1,176 @@
+require 'toast/config_dsl/association'
+require 'toast/config_dsl/collection'
+require 'toast/config_dsl/single'
+
+# context for expose{} blocks
+class Toast::ConfigDSL::Expose
+  include Toast::ConfigDSL::Common
+  include Toast::ConfigDSL::DefaultHandlers
+
+  # directives
+  def writables *attributes
+    stack_push "writables(#{attributes.map(&:inspect).join(',')})" do
+
+      check_symbol_list attributes
+
+      model_class = @config_data.model_class
+
+      attributes.each do |attr|
+
+        model = model_class.new
+        setter = (attr.to_s + '=').to_sym
+
+        unless (model.respond_to?(setter) and model.method(setter).arity == 1)
+          raise_config_error "Exposed attribute setter not found: `#{model_class.name}##{attr}='. Typo?"
+        end
+
+        unless (model.respond_to?(attr) and model.method(attr).arity.in?([-1,0]))
+          raise_config_error "Exposed attribute getter not found `#{model_class.name}##{attr}'. Typo?"
+        end
+
+        @config_data.writables << attr
+      end
+    end
+  end
+
+  def readables *attributes
+    stack_push "readables(#{attributes.map(&:inspect).join(',')})" do
+
+      check_symbol_list attributes
+
+      model_class = @config_data.model_class
+
+      attributes.each do |attr|
+        model = model_class.new
+
+        unless (model.respond_to?(attr) and model.method(attr).arity.in?([-1,0]))
+          raise_config_error "Exposed attribute getter not found `#{model_class.name}##{attr}'. Typo?"
+        end
+
+        @config_data.readables << attr
+      end
+    end
+  end
+
+  def via_get &block
+    stack_push 'via_get' do
+      @config_data.via_get =
+        OpenStruct.new(permissions: [],
+                       handler: canonical_get_handler)
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_get).instance_eval &block
+
+    end
+  end
+
+  def via_patch &block
+    stack_push 'via_patch' do
+      @config_data.via_patch =
+        OpenStruct.new(permissions: [],
+                       handler: canonical_patch_handler)
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_patch).instance_eval &block
+
+    end
+  end
+
+  def via_delete &block
+    stack_push 'via_delete' do
+      @config_data.via_delete =
+        OpenStruct.new(permissions: [],
+                       handler: canonical_delete_handler)
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_delete).instance_eval &block
+
+    end
+  end
+
+
+  def collection name, as: 'application/json', &block
+    stack_push "collection(#{name.inspect})" do
+      model_class = @config_data.model_class
+
+      unless block_given?
+        raise_config_error 'Block expected.'
+      end
+
+      unless name.is_a?(Symbol)
+        raise_config_error "collection name expected as Symbol"
+      end
+
+      unless model_class.respond_to?(name)
+        raise_config_error "`#{name}' must be a callable class method."
+      end
+
+      @config_data.collections[name] =
+        OpenStruct.new(base_model_class: model_class,
+                       collection_name: name,
+                       media_type: as,
+                       max_window: Toast.settings.max_window)
+
+      Toast::ConfigDSL::Collection.new(@config_data.collections[name]).
+        instance_eval(&block)
+
+    end
+  end
+
+  def single name, &block
+    stack_push "single(#{name.inspect})" do
+
+      model_class = @config_data.model_class
+
+      unless model_class.respond_to?(name)
+        raise_config_error "`#{name}' must be a callable class method."
+      end
+
+      unless block_given?
+        raise_config_error 'Block expected.'
+      end
+
+      @config_data.singles[name] = OpenStruct.new(name: name, model_class: model_class)
+
+      Toast::ConfigDSL::Single.new(@config_data.singles[name]).
+        instance_eval(&block)
+    end
+  end
+
+  def association name, as: 'application/json', &block
+    stack_push "association(#{name.inspect})" do
+
+
+      model_class = @config_data.model_class
+
+      unless name.is_a?(Symbol)
+        raise_config_error "association name expected as Symbol"
+      end
+
+      unless model_class.reflections[name.to_s].
+               try(:macro).in?([:has_many,
+                                :has_one,
+                                :belongs_to,
+                                :has_and_belongs_to_many])
+        raise_config_error 'Association expected'
+      end
+
+      unless block_given?
+        raise_config_error 'Block expected.'
+      end
+
+      target_model_class = model_class.reflections[name.to_s].klass
+      macro    = model_class.reflections[name.to_s].macro
+      singular = macro.in? [:belongs_to, :has_one]
+
+      @config_data.associations[name] =
+        OpenStruct.new(base_model_class: model_class,
+                       target_model_class: target_model_class,
+                       assoc_name: name,
+                       media_type: as,
+                       macro:      macro,
+                       singular:   singular,
+                       max_window: singular ? nil : Toast.settings.max_window)
+
+      Toast::ConfigDSL::Association.new(@config_data.associations[name]).
+        instance_eval(&block)
+    end
+  end
+end

data/lib/toast/config_dsl/settings.rb

@@ -0,0 +1,35 @@
+require 'toast/errors'
+
+class Toast::ConfigDSL::Settings
+  include Toast::ConfigDSL::Common
+
+  class AuthenticateContext
+    def fail_with hash
+      raise Toast::Errors::CustomAuthFailure.new(hash)
+    end
+  end
+
+  def toast_settings &block
+    stack_push 'toast_settings' do
+      self.instance_eval &block
+    end
+  end
+
+  def max_window size
+    if size.is_a?(Integer) and size > 0
+      Toast.settings.max_window = size
+    elsif size == :unlimited
+      Toast.settings.max_window = 10**6 # yes that's inifinity 
+    else
+      raise_config_error 'max_window must a positive integer or :unlimited'
+    end
+  end
+
+  def link_unlink_via_post boolean
+    Toast.settings.link_unlink_via_post = boolean
+  end
+
+  def authenticate &block
+    Toast.settings.authenticate = block
+  end
+end

data/lib/toast/config_dsl/single.rb

@@ -0,0 +1,15 @@
+class Toast::ConfigDSL::Single
+  include Toast::ConfigDSL::Common
+  include Toast::ConfigDSL::DefaultHandlers
+
+  def via_get &block
+    stack_push 'via_get' do
+
+      @config_data.via_get =
+        OpenStruct.new(permissions: [],
+                       handler: single_get_handler(@config_data.model_class, @config_data.name))
+
+      Toast::ConfigDSL::ViaVerb.new(@config_data.via_get).instance_eval &block
+    end
+  end
+end