00:02:23 <donri> yea safecopy will handle the nested migrations for you right, so should work to have old Page refer to latest Bar even if the decoded data is an old Page with an old Bar
00:05:25 <stepkut> up
00:05:26 <stepkut> yup
00:06:31 <alpounet> whaaat
00:06:46 <donri> and there should be no *code* using old versions because that's just for stored data, not running code
00:06:46 <alpounet> i'm gonna need your help stepkut
00:07:03 <stepkut> k
00:07:10 <alpounet> tell me when you're available. getting a few issues in PreProcess
00:07:14 <stepkut> donri: right
00:08:19 <alpounet> particularly with the LinkPage not refering to a page slug for now, but since i'm not sure where you are parsing stuffs from, i'm not sure how to add page slug parsing
00:09:20 <alpounet> oh
00:09:30 <alpounet> maybe i should just generate the page slug from the title there, again
00:10:27 <alpounet> yeaaah, probably
00:10:40 <stepkut> let me look
00:11:02 <alpounet> Clckwrks.Page.PreProcess
00:11:29 <stepkut> there are a couple options
00:12:13 <stepkut> we could try to lookup the Page associated PageId and generate the slug from that, we could set the page slug to nothing, or we could use the optional title when present to generate a slug
00:13:12 <alpounet> i'd go with calling my super slug generation function on ttl
00:13:20 <alpounet> even if it's "Untitled"
00:13:47 <alpounet> what about you?
00:13:57 <donri> if you get the Page for a PageId, won't you have a slug already?
00:14:19 <stepkut> donri: right.. just means you have to do an extra query to get the Page
00:14:39 <alpounet> we already do a query to get the title anyway
00:15:07 <stepkut> alpounet: then we should change that to GetPageTitleAndSlug :)
00:15:26 <alpounet> alright :)
00:15:49 <stepkut> the title in LinkPage is really just what you want to appear inside the <a> tag
00:16:21 <stepkut> but, when you click on that, it would be best if you saw the descriptive page slug that comes from either the real page title or whatever the user has specifically set
00:17:00 <alpounet> stepkut, shouldn't we keep GetPageTitle and add GetPageTitleAndSlug right after?
00:17:11 <alpounet> or you don't see any use case where we'd need only the title
00:23:28 <stepkut> yes
00:24:07 <stepkut> that is what I meant, though I did not state it clearly
00:44:35 <alpounet> alright, Clckwrks.Menu.Edit now
00:45:55 <stepkut> :)
00:55:17 <alpounet> stepkut, Clckwrks.Menu.Edit requires a PathInfo instance for ClckURL
00:55:20 <alpounet> for "decode"
00:55:28 <alpounet> any way to replace that with our web-routes stuffs?
00:55:33 <stepcut> hmm
00:55:39 <stepcut> certainly
00:56:47 <stepcut> though.. we can keep the PathInfo instances around too
00:56:59 <stepcut> the use of PathInfo here is invisible to the user I think
00:58:01 <alpounet> i was more affraid of it producing inconsistent URLs, stepcut
00:58:08 <alpounet> since the URL scheme i different
00:58:14 <alpounet> is
00:58:20 <stepcut> doesn't matter
00:58:50 <alpounet> ok
00:59:12 <stepcut> the menu editor uses the PathInfo instance to create strings to use as values in the fields and then it parses those values back to get the urls that it stuck in there
00:59:28 <alpounet> ok
00:59:29 <stepcut> but I don't think those urls are ever visible to the user
00:59:43 <stepcut> so, it just has to be a matched pair.. same encoder/decoder
00:59:59 <stepcut> but we could use parseStrings and unparseStrings instead, http://hackage.haskell.org/packages/archive/boomerang/1.2.0/doc/html/Text-Boomerang-Strings.html
01:00:24 <alpounet> i'll let you modify that
01:00:36 <alpounet> i'll get drunk with my bourbon if i succeed at building clckwrks
01:00:38 <stepcut> if it is working I have no real desire to modify it at this time
01:00:53 <stepcut> do you have an acct on clckwrks.com ?
01:02:48 <alpounet> i logged in with my google account
01:02:50 <alpounet> but can't do anything
01:03:05 <stepcut> yeah, there isn't much to do yet
01:03:10 <alpounet> oh great
01:03:12 <alpounet> now i get
01:03:14 <alpounet>     No instances for (Web.Routes.PathInfo.PathInfo ProfileDataURL,
01:03:14 <alpounet>                       Web.Routes.PathInfo.PathInfo AdminURL)
01:03:14 <alpounet>       arising from a use of `Web.Routes.PathInfo.toPathSegments'
01:03:20 <stepcut> but I can assign this bug to you and then close it when you are done
01:03:28 <alpounet> when trying to derivePathInfo for ClckURL
01:03:39 <stepcut> then you can accumulate points and redeem them for booze someday
01:03:51 <stepcut> isn't there already a derivePathInfo for ClckURL?
01:03:54 <stepcut> or did you remove it?
01:04:02 <alpounet> i commented it out
01:04:10 <alpounet> to figure out the necessary changes
01:04:15 <stepcut> apparently you commented out some others as well
01:04:37 <stepcut> in theory, we should be able to make the PathInfo instances use the boomerang stuff
01:04:51 <stepcut> not sure if I have ever documented how though
01:05:55 <alpounet> it's a bit late for that :D
01:05:58 <alpounet> anyway
01:07:43 <alpounet> i haven't removed any other instance, since there isn't any other
01:07:57 <alpounet> oooooooh wait
01:07:58 <alpounet> i did
01:08:15 <alpounet> in Admin/URL.hs and ProfiteData/URL.hs
01:14:45 <alpounet> YEAH!
01:14:58 <alpounet> Building clckwrks-0.9.0...
01:14:58 <alpounet> Preprocessing library clckwrks-0.9.0...
01:14:58 <alpounet> [38 of 38] Compiling Clckwrks.Server  ( Clckwrks/Server.hs, dist/build/Clckwrks/Server.o )
01:14:58 <alpounet> Registering clckwrks-0.9.0...
01:18:38 <stepcut> nice!
01:18:44 <stepcut> are the urls pretty now?
01:18:48 <stepcut> and sluggish?
01:19:08 <alpounet> no
01:19:16 <alpounet> because we don't call out to clckRoute
01:19:20 <alpounet> or whatever name i gave it
01:19:29 <stepcut> oh yeah
01:19:37 <alpounet> so now is the moment you give me the magic change to make
01:19:42 <alpounet> and everything works out of the box, boom
01:21:23 <alpounet> so yeah it's clckRoute
01:22:48 <stepkut> i think we need to handle the issue with combining PathInfo and boomerang, since some of the plugins also define routes using PathInfo
01:24:52 <alpounet> i can switch the plugins over to boomerang
01:24:57 <stepkut> in Main.hs there is a call to makeSitePI
01:24:59 <alpounet> if needed :)
01:25:25 <alpounet> yes, mkSitePI
01:25:48 <alpounet> (and it's Server.hs i guess)
01:26:24 <stepkut> needs to be something like, setDefault Home $ boomerangSite (runRouteT route) sitemap
01:26:43 <stepkut> ah there is one in Main.hs as well
01:26:48 <zzing_> If I wanted to do a sort of revision control wiki, would darks be a reasonable way to store files?
01:26:50 <stepkut> not sure which one is actually used
01:27:07 <stepkut> zzing_: yes.
01:27:33 <stepkut> zzing_: that is how gitit works
01:27:41 <zzing_> gitit?
01:27:59 <stepkut> you could use filestore http://hackage.haskell.org/package/filestore-0.4.2
01:28:04 <stepkut> http://hackage.haskell.org/package/gitit-0.9.0.1
01:28:06 <zzing_> interesting
01:28:17 <zzing_> oh I like that
01:28:24 <zzing_> thanks
01:29:12 <stepkut> no problem
01:33:09 <alpounet> stepkut, oh, i was talking about clckwrks's Server.hs
01:33:14 <alpounet> not clckwrks-dot-com's Main.hs
01:34:54 <stepkut> right.. I am not sure the one in Server.hs actually gets called
01:35:01 <stepkut> due to the complications of registering plugins
01:35:26 <alpounet> i don't think so
01:35:31 <alpounet> the module doesn't seem to be exported
01:35:34 <alpounet> (in the .cabal file)
01:36:05 <alpounet> stepkut, uh, i'm going to need to boomerang-ize clckwrks-dot-com too
01:36:32 <stepkut> right
01:36:47 <stepkut> or make PathInfo and boomerang live together
01:36:55 <stepkut> or both!
01:38:48 <alpounet> oh
01:39:02 <alpounet> there's a bunch of calls to PathInfo functions in Main.hs
01:39:04 <alpounet> damn
01:39:46 <stepkut> let's see how hard it is to make a PathInfo instance when you have a boomerang route already
01:39:55 <stepkut> should not be hard
01:43:27 <zzing_> Is heist the easiest way to work with templates that should stay in html?
01:44:16 <stepcut> zzing_: depends what you are trying to do.. but probably
01:44:54 <zzing_> When I was looking at it earlier today under snap it looked somewhat tricky
01:45:16 <stepcut> zzing_: I'm not clear what you mean by, "templates that should stay in html"
01:45:50 <zzing_> stepcut, I want a template designer to edit html and essentially have it work fairly easily.
01:46:02 <zzing_> So not having to convert it to haskell
01:46:20 <stepcut> that is what heist aims to offer
01:46:37 <stepcut> HSP does as well.. but is not quite there in terms of non-Haskell user friendliness
01:47:57 <zzing_> Wasn't HSP have to be converted to haskell code first?
01:50:03 <stepcut> zzing_: yes.. but that is done automatically by a pre-processor
01:50:15 <stepcut> but it does involve recompiling the server to see the changes
01:50:37 <stepcut> or using hs-plugins to do that automatically and more quickly
01:50:47 <zzing_> So it means recompiling the app - are there advantages to HSP over heist?
01:51:19 <stepcut> HSP gives you type safety, heist gives you the ability to change templates with out having to recompile, but with less type safety
01:51:31 <stepcut> also, with heist, you still sometimes have to recompile
01:51:47 <zzing_> What would the type safety of HSP mean to a web app?
01:52:45 <stepcut> heist is a combination of haskell code + xml files. You can do a lot by changing the XML files, heist has no mechanism for doing anything programmatic. For example, you can not map a template over a list of values. You have to do that in Haskell code.
01:53:18 <stepcut> in heist, you might try to include template fragments like header/footer/etc which do not actually exist
01:53:23 <stepcut> but you won't see that at runtime
01:53:34 <alpounet> s/at/before/ ?
01:53:43 <stepcut> in HSP if you trying to include the 'footer' and there was no such function, you would get a compile time error
01:54:00 <stepcut> s/at/until/
01:54:46 <zzing_> I suppose if it is easy to recompile the app, it wouldn't make much difference
01:56:48 <stepcut> that is the long term plan
01:57:04 <stepcut> but.. there is still some work to be done
01:57:11 <stepcut> hence, heist is a reasonable alternative in the meantime
01:57:29 <zzing_> I don't really want to have to redo anything in the future
01:57:39 <zzing_> Anything I can get away with at least
02:24:29 <stepkut> well, it's really up to you to decide. HSP is certainly not pain free.
11:50:56 <alpounet> higgset should get a major version bump today
12:28:36 <Entroacceptor> indeed!
12:58:20 <HugoDaniel> http://hpaste.org/70881
12:58:42 <HugoDaniel> i find myself doing those a lot in happstack
13:13:36 <zzing_> mightybyte, I think the issue I was having is splices not being completely obvious to me
13:15:52 <Entroacceptor> HugoDaniel: Oo
15:20:37 <stepkut> alpounet: weren't you working on a replacement for the clckwrks Makefile that was written in Haskell?
15:42:24 <alpounet> stepkut, yeah i was
15:42:35 <alpounet> but that implied using a zip library
15:42:38 <alpounet> with a bunch of deps
15:42:48 <alpounet> so i wasn't sure of the way to go from there
15:43:48 <alpounet> thought about writing my own
15:43:58 <stepkut> zip-archive?
15:44:03 <alpounet> yeah
15:44:03 <stepkut> there is also LibZIp
15:44:51 <alpounet> well yeah
15:44:57 <alpounet> that requires libzip to be installed
15:45:06 <alpounet> all of this is a pain to handle on Windows
15:45:18 <stepkut> ah
15:45:19 <alpounet> but i just remembered there's also gd, libmagic etc as C dependencies
15:45:27 <stepkut> :-]
15:45:36 <stepkut> only if you install clckwrks-plugin-media
15:47:50 <alpounet> right
15:47:54 <alpounet> which is going to be the case anywya
15:49:18 <stepkut> well, not for all sites
15:50:03 <alpounet> stepkut, so basically i was waiting for us to choose a direction
15:50:08 <alpounet> for that zip thing
16:20:53 <stepkut> looks like I added .Texts to boomerang, but never got around to updated web-routes-boomerang to use it
16:21:01 <stepkut> or even uploading it to hackage
16:27:05 <alpounet> i have the anyText function
16:27:06 <alpounet> if you want
16:27:37 <stepkut> already exists in .Texts
16:53:20 <stepkut> alpounet: I pushed a patch to web-routes-boomerang that adds two functions that should make it easy to create a PathInfo instance from a boomerang spec
16:53:25 <stepkut> but I have not tested
16:53:30 <stepkut> now I have to make food and stuff
16:53:38 <stepkut> 'tis a national holiday where I am
16:53:45 <alpounet> yeah
16:53:49 <alpounet> independence day
16:54:49 <stepkut> the new functions use [Text] instead of [String].. which is the right thing to do in the long term
16:54:54 <stepkut> well, even the short term
16:55:07 <stepkut> but we may need to migrate some other stuff too
16:55:18 <stepkut> but if we are breaking code, that would also be a good time to fix the Router type
16:55:53 <stepkut> but at the very least, I am now pretty confident that we can create PathInfo instances from boomerang
16:55:56 <donri> stepkut: i want the inverse of that
16:56:03 <donri> pathinfo -> router
16:56:08 <stepkut> basically, I just use getParserState and setParserState
16:56:13 <stepkut> donri: equally possible, just not done
16:56:48 <stepkut> parsec and the router both operate on [Text] and the position information is basically just (Int, Int)
16:57:03 <donri> i'm thinking it'd be nice for migrating a site from pathinfo to boomerang without having to write all routes at once
16:57:04 <stepkut> so it is just a matter of pulling the state out of one and plugging it into the other
16:57:12 <stepkut> right
16:57:31 <stepkut> that is what we are doing actually
16:57:51 <stepkut> but, in this case, the type-level type is still PathInfo based, and only some of the sub-paths are boomerang
16:57:57 <donri> or for that matter, using plugins in your boomerang site when the plugin is only pathinfo (e.g. maybe you don't need pretty urls for something only seen under the hood, like yui)
16:57:57 <stepkut> however, we actually have both
16:58:06 <stepkut> because the authenticate stuff is still PathInfo based
16:58:16 <stepkut> right
16:58:21 <stepkut> we want both ways
16:58:28 <donri> (although i actually provide both in yui :p)
16:58:29 <stepkut> and it looks pretty straight-forward
16:59:32 <alpounet> ACTION has written boomerang routes for the authenticate stuffs too
17:01:31 <donri> .o( pipes based portable makefile replacement... )
18:50:49 <zzing> Does the main website's theme have a name?
18:51:20 <stepcut> clckwrks-theme-happstack
18:52:00 <stepcut> it's bundled with the happstack.com source, darcs get http://src.seereason.com/happstack-clckwrks
18:52:12 <stepcut> clckwrks.com has its own theme bundled with the clckwrks source
19:02:13 <donri> stepcut: if i wanna play with making a theme that may or may not end up good enough to be used for something, should I 1) work on the clckwrks theme, 2) the happstack theme or 3) new theme, new site, 4) new theme, clckwrks site, 5) new theme, happstack site? :)
19:03:20 <stepcut> which site do you think is worst right now? happstack.com or clckwrks.com ?
19:04:12 <donri> duno, they're both kind of good, kind of bad :)
19:05:00 <donri> maybe it's easiest to go with 3, less dependencies to worry about building?
19:05:12 <donri> then if it ends up nice it's easy to have one of the sites use it?
19:05:45 <stepcut> up to you
19:05:52 <donri> although then i have to set up a site, hm
19:05:59 <stepcut> happstack.com has fewer dependencies
19:06:02 <donri> aha
19:06:25 <stepcut> and we haven't modified the theme much recently :)
19:07:31 <donri> i find myself a bit reluctant to work on this though because there's so many steps involved just to get started
19:07:41 <donri> at least in part because not all dependencies are on hackage
19:08:23 <stepcut> which dependencs are not on hackage yet?
19:08:28 <donri> and i guess, even then i have to build multiple projects just to test things
19:08:33 <stepcut> oh.. the clckwrks dependencies :)
19:08:35 <zzing> stepcut: being that I have already copied the theme in a fashion and now I am putting it in a web template, I wanted to name it something appropriate
19:09:12 <stepcut> donri: for theme stuff I just use a script that does runhaskell and -i../clckwrks-theme-happstack
19:09:35 <donri> stepcut: well, i use cabal-dev :)
19:09:43 <donri> and sandboxer for multiproject builds
19:09:47 <stepcut> zzing: it has no name other than 'clckwrks-theme-happstack'.. so you can name it whatever you please
19:09:50 <donri> not sure if that works with runghc
19:10:04 <stepcut> donri: no idea
19:10:18 <stepcut> donri: eventually you will be able to use hs-plugins and just edit the files and hit refresh
19:10:21 <stepcut> but.. not there yet
19:10:24 <donri> yea
19:10:43 <stepcut> well.. actually there are #ifdefs in there and it make actually work (on linux only) still
19:12:09 <donri> "sandboxer also sets $GHC_PACKAGE_PATH to help with applications that call runghc directly"
20:15:42 <alpounet> stepcut, ok for the pathinfo / boomerang thing. given everything you've said, i guess the release is not there yet?
20:15:49 <alpounet> so i should pull and test against that
20:15:51 <alpounet> ?
20:22:05 <stepcut> sure
20:22:15 <stepcut> I will look at it more tomorrow
20:22:22 <stepcut> gotta shower, and go eat now
20:22:31 <stepcut> and drink and stuff
20:29:17 <alpounet> heh ok
20:29:25 <alpounet> will work on this tomorrow, too