World: r3wp

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]
	]

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

Also, if there is no content, then the content-length header is not 
set ... 

Here's my suggested changes at the bottom 


http://rebol.wik.is/Rebol3/Schemes/Http/Prot-http.r/Make-http-request

1.1 didn't work since chunked encoding was broken, so they reverted 
to 1.0. Proper 1.1 support is on the list to fix.

However, chunked encoding needs to be fixed first, before 1.1 support 
can be reenabled.

The .rlp http client was also written before the Unicode changes 
were finished, so we need to review for those fixes too.

That would affect the string-vs-binary situation.

I'm looking at the .r source ...

Which has only been patched a few times, not yet properly reworked.

well, I think not setting the content-length header might be bug 
..