World: r3wp

Ok.

And there's this in prot-http.r

crlfbin: #{0D0A} 
crlf2bin: #{0D0A0D0A} 
crlf2: to string! crlf2bin 

This stuff should be in some reusable module too

prot-http.r is itself a reusable module.

I think that the preprocessor will actually mix in the mixins itself, 
as if they were part of the original source of the calling modules. 
That way if you want to do selective import you would split your 
module into two, one that contains the shared stuff, and another 
that contains the local stuff that references the shared module. 
It's not as hard as it sounds.

maybe instead of make-scheme there could be something like make-network-scheme 
where these are automatically accessible?

How about let's worry about the refactoring later, and focus on getting 
it to work now. We can refactor on the way.

still leads to duplication of code

yeah .. always put off today what can be done tomorrow :)

Which we can deduplicate during the refactoring :)

Kaj raised the point of how much memory r2 and r3 take compared with 
the clone ...

Yes, another point for the refactoring. The clone doesn't do as much 
though.

read and write are very similar ... can we do this?

		read: func [
			port [port!]
			/write data
		] [
			either any-function? :port/awake [

    unless open? port [cause-error 'Access 'not-open port/spec/ref] 
				if port/state/state <> 'ready [http-error "Port not ready"] 
				port/state/awake: :port/awake 
				do-request port 
				port
			] [
				sync-op port either write [ data ] [[]]
			]
		] 
		write: func [
			port [port!] 
			value
		] [

   unless any [block? :value any-string? :value] [value: form :value] 

   unless block? value [value: reduce [[Content-Type: "application/x-www-form-urlencoded; 
   charset=utf-8"] value]] 
			read/write port data 
		]

should be

read/write port [parse-write-dialect port value]

well... can't use /write as the refinement .. but the idea ...

heh ..Gabriele must be top down programming .. .he writes the higher 
order code first and then the supporting definitions.

He programs in the RLP and then it topologically sorts the code.

Dunno what that means .. but it's the same in the rlp

Ah, less topological sorting than I thought.

Which is the latest ... prot-http.rlp or prot-http.r ?

later ..

ie. is prot-http.r generated from the rebol literate programming 
document?

prot-http.r is the latest. prot-http.rlp was just uploaded later.

The original prot-http.r was generated from .rlp, but has since been 
revised directly. Look at the revision history with LF and DIFF.

ok,  I see this

        spec/headers: third make make object! [
in the rlp, and in the .r

	spec/headers: body-of make make object! [

so they are different.

body-of would work, third wouldn't.

so the rlp is correct?  and the .r is not ?

reverse that ...

The .rlp version is more than 2 years old, the .r is more recent 
and works.

oh ...ok.

works, sort-of, still needs work.

spec/headers: body-of make make object! [
		Accept: "*/*" 
		Accept-Charset: "utf-8" 
		Host: either spec/port-id <> 80 [
			rejoin [form spec/host #":" spec/port-id]
		] [
			form spec/host
		] 
		User-Agent: "REBOL"
	] spec/headers 
what exactly is this code doing?

Makes a object containing the standard http headers derived from 
the template object, also defined in a literal spec.

Has an extra object of overhead.

so spec/headers contains the standard template, and it adds these 
other members to this template?

Yeah, I think so. I shoud check for sure. This is why I am starting 
woth mezz-ports.r first.

Something looks reversed, like spec/headers is using the specific 
headers as a template rather than the reverse. Don't know why yet.

So, it is modifying the original spec/headers by adding these new 
members to spec/headers ...  as a way of modifying the object in 
situ as it were

I wonder why he can't do this 

spec/headers: make spec/headers [
		Accept: "*/*" 
		Accept-Charset: "utf-8" 
		Host: either spec/port-id <> 80 [
			rejoin [form spec/host #":" spec/port-id]
		] [
			form spec/host
		] 
		User-Agent: "REBOL"
]

oh ... headers is a block and not an object!

I think that the Accept, Accept-Charset and User-Agent headers are 
the defaults, and spec/headers are the user-specifiable options.

So he is using make object! to ensure that he has unique members 
in the created block!

Actually, an object is created. Then it is converted to a string 
later.

Yeah .. seems a rather round about way of doing things.

There are a lot of interesting tricks you can do with objects that 
are much trickier with string-format headers. It's worth it.

We can look into reducing the overhead though.

In make-http-request there is this

	result: rejoin [
		uppercase form method #" " 
		either file? target [next mold target] [target] 
		" HTTP/1.0" CRLF
	] 

since it is stated that http 1.1 is being supported, we should change 
this to 1.1

yeah ... some function that appends one block of set pairs to another 
without overwriting the original ...

make-http-request  says that content is [ any-string! none! ]
it then converts this to binary.

But if we want to send a binary file using PUT,  I think this must 
mean we need to convert that file to string first ... which seems 
wrong.

we should allow binary! as well ... and change the code to 

if content [
		if string? [ content: to binary! content ] 
		repend result ["Content-Length: " length? content CRLF]
	]