archimag / restas Goto Github PK

It would be useful, at least, for debugging routes configuration, if restas was able to generate a tree of all possible routes, registered in the system.

This is really nice, are you still maintaining this repo?

It points to the cl-closure-template googlecode repo, which is a 404.

I don't really understand it, but this is what I get:

; caught ERROR:
;   (during macroexpansion of (RESTAS:MOUNT-MODULE -HTML- ...))
;   The value-HTML-is not of typeLIST

More context at http://report.quicklisp.org/2016-06-22/failure-report/restas.html#restas-doc

The documentation on the website still refers to setting *baseurl* in mount-module rather than setting :url.

If a PR with new docs is excepted, will the website be regenerated?

https://github.com/archimag/restas/blob/master/contrib/restas-daemon.lisp#LC363 wants to call swanks create-server with a key :coding-system, although that key disappeared in http://common-lisp.net/viewvc/slime/slime/swank.lisp?view=log#rev1.763

I need to be able to set the render method of a module from within the module, doing it in define-module or mount-module would be inconvenient. After 10 minutes with the source, I came up with this hack:

(defun set-render-method (method &optional (package *package*))
  (let ((traits (gethash (find-package package) restas::*pkgmodules-traits*)))
    (setf (gethash :render-method traits)
      (alexandria:named-lambda make-render-method () method)))
  (restas:reconnect-all-routes))

Is there a better way? I could implement something better and send a pull request, but I don't quite understand the implementation of the new module system yet.

Dear Andrey,
sorry to disturb you, I got trapped in how to use RESTAS to publisher an exist file,such as .html . .txt etc.Even though a package which called "restas.file-publisher",I couldn't use it properly,so as I 'm a newbee about lisp usage to do practical works,
Please give me a hand and give me more examples about publishing static files,
Your sincerely ,
lisper 03

Please consider adding :description, :author and :license information to your ASDF system. This will greatly help Quicklisp users and make it easier for them to report bugs.

More information:

http://blog.quicklisp.org/2015/05/looking-for-more-metadata.html
https://www.quicklisp.org

Hi!

seems that I am getting some trouble compiling

https://github.com/archimag/restas/blob/master/example/example-1.lisp

sbcl (version 1.3.3 on debian if that matters)

the error is
The value RESTAS.PUBLISH-RST::-RAW- is not of type LIST.
[Condition of type TYPE-ERROR]

maybe something wrong here?

Compiled restas with slime before, then use without slime.
I got an error like "There is no package named 'SWANK'".

http://stackoverflow.com/questions/38278897/why-clozure-cl-cannot-load-my-code-without-slime

It would be nice to have a macros (e. g. cdefun) like define-route, but defining a generic function, which takes an additional argument - the submodule-designated symbol. Each mount-submodule also generate methods for those function, specialized for the symbol, specified in it. Those methods will just put the code of the function into the submodule context, with all dynamically scoped variables will seem like the function is called from a route of this submodule. For example:

; mod1:

(defvar *var* 0)
(cdefun add-var (a) (+ *var* x) ) ; <-- the function here depend on dynamically scoped context

; mod2:

(mount-submodule sm1 (#:mod1) ; <-- Create two different contexts
   (mod1:*var* 1))                         ;     /
(mount-submodule sm2 (#:mod1) ; <-
   (mod1:*var* 2))

; Call function in different contexts
(mod1:add-var 'sm1 1) ;--> 2
(mod1:add-var 'sm2 1) ;--> 3

;mod3:

(mount-submodule sm1 (#:mod1)
  (mod1:*var* 41))

(mod1:add-var 'sm1 1) ;--> 42

Here the first invocation and the third will refer to the different methods, because the symbols mod2:sm1 and mos3:sm1 are different.

I know one way to achieve such results now -- using the restas:with-context macro. But it is quite verbose (and undocumented, as far as I know):

(restas:with-context (second (gethash 'sm1 *submodules*))
   (mod1:add-var 1))

And it still handles restas:genurl improperly (relative to the current module, not to the 'sm1).
It's just a proposal, may be there is a more elegant solution.

What's the new way to do that now?
Thanks for any help.

Regards,
Ph.

When calling define-policy, the keyword arguments in %define-policy that were absent in define-policy are set to NIL, and do not take their default values. This can lead to errors when the NIL value is not meaningful for that option, as described in this question: https://stackoverflow.com/q/58257183/124319

There are different fixes possible, that basically boils down to handling NIL values in %define-policy or preventing the define-policy macro from giving keyword arguments when they are nil. I am not submitting a patch at the moment because I am not sure about which way seems better for you.

giving the :render-method argument to define-module macro doesn't seem to work, I get an internal error.
Whereas as using the same argument :render-method inside the define-route works.

:(

Hello,

I am trying to figure out why this issue appeared:
archimag/restas-directory-publisher#7
I think changing this function

https://github.com/archimag/restas/blob/master/src/route.lisp#L27

with

(defun` route-render-method (route)
  (funcall (or (slot-value route 'render-method)
               (and (module-render-method (route-module route))
		    #'(lambda () (module-render-method (route-module route))))
               (lambda () #'identity))))

resolve the rendering issue; but because i am not able to understand the internal machinery of the library i can not consider this a solution for that bug, just an hint. I hope can be useful anyway.

Bye!
C.

I have prepared a small patch that fixes the assumption that all urls use the :http uri scheme

From 8deaa520518d8c24e4fb140929d36c3e90ac9fd3 Mon Sep 17 00:00:00 2001
From: Brian Hollis <[email protected]>
Date: Sun, 26 Feb 2012 01:11:22 -0600
Subject: [PATCH] Modified gen-full-url to detect bound ssl acceptor and set
 uri scheme accordingly.

---
 src/route.lisp |   14 ++++++++------
 1 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/route.lisp b/src/route.lisp
index 6c3cea1..a4fe5c6 100644
--- a/src/route.lisp
+++ b/src/route.lisp
@@ -211,12 +211,14 @@
                                        (submodule-full-baseurl *submodule*)
                                        (route-symbol-template route))
                           args)))
-    (setf (puri:uri-scheme uri)
-          :http)
-    (setf (puri:uri-host uri)
-          (if (boundp 'hunchentoot:*request*)
-                      (hunchentoot:host)
-                      "localhost"))
+
+    (if (boundp 'hunchentoot:*request*)
+       (setf (puri:uri-scheme uri) (if (hunchentoot:ssl-p) :https :http)
+             (puri:uri-host uri) (hunchentoot:host))
+
+       (setf (puri:uri-scheme uri) :http
+             (puri:uri-host uri) "localhost"))
+
     (puri:render-uri uri nil)))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
--
1.7.6.4

Decorators defined on define-route are lost when this module is mounted as sub-module into other module.

My simplified situation is like this:

packages.lisp

(restas:define-module #:test
  (:use #:cl))

(restas:define-module #:test.admin
  (:use #:cl))

admin.lisp

(in-package #:test.admin)

(defclass login-required-route (routes:proxy-route) ())
(defmethod restas:process-route ((route login-required-route) bindings)
  (break)) ;; Not breaking
(defun @login-required (route)
  (make-instance 'login-required-route :target route))

(restas:define-route admin-index ("")
  (:decorators '@login-required)
  "In admin")

test.lisp

(in-package #:test)

(restas:mount-module admin (#:test.admin)
  (:url "admin"))

Going to /admin/ is not actually breaking in this case.

Here is a simple RESTAS application:

(require 'asdf)

(asdf:operate 'asdf:load-op '#:restas)
(restas:define-module #:pack
   (:use #:cl))

(in-package #:pack)
(restas:define-route route ("file/*path" :method :get) (format nil "~a - path" path))
(restas:define-route person-change-route ("person:(id)")
                                    (format nil "~a - person" id))

(restas:define-route nooa ("impossible:(siid)" :method :get) (format nil "~a - imposible" siid))

(restas:start '#:pack :port 8080)

If it is runned on sbcl 1.0.54, hunchentoot 1.2.2, RESTAS 20111203-git, produces strange begaviour:
http://localhost:8080/person1 ---> NIL - imposible
It goes by the wrong, third, route.
If you comment first, or last route, your will receive:
http://localhost:8080/person1 ---> 1 - person