Rewrite macro 'with-curl-easy'

Use a variable to initialize the curl handler, instead of
creating the class inside the macro. This allows to subclass
`<curl-easy>`.

  with-curl-easy(curl = make(<curl-easy>))
    curl.curl-url := "http://example.com";
    curl.curl-verbose := #f;
    curl-easy-perform(curl);
  end;

Now is possible to pass options to the macro. It makes less verbose
the code.

  with-curl-easy(curl = make(<curl-easy>),
                 url = "http://example.com",
                 verbose = #f)
    curl-easy-perform(curl)
  end;

Author: fraya

documentation/source/introduction.rst

@@ -34,7 +34,7 @@ In libcurl, you create a handle using `curl_easy_init
 <https://curl.se/libcurl/c/curl_easy_init.html>`_. In the Open Dylan
 wrapper, you create an object of the :class:`<curl-easy>` class.
 
-.. code-block:: c
+.. code-block:: C
    :caption: C example
 
    CURL *curl = curl_easy_init();
@@ -43,17 +43,23 @@ wrapper, you create an object of the :class:`<curl-easy>` class.
      curl_easy_cleanup(curl);
    }
 
+The macro :macro:`with-curl-easy` handles both initialization and
+automatic cleanup when it is no longer accessible. If initialization
+fails, a :class:`<curl-init-error>` exception is raised.
+
 .. code-block:: dylan
    :caption: Dylan example
 
-   with-curl-easy (curl)
-     ...
+   block ()
+     with-curl-easy (curl = make(<curl-easy>))
+       // perform request
+       // gather information about the request
+     end;
+   exception (err :: <curl-init-error>)
+     format-err("Error initializing curl: %s\n",
+                 err.curl-error-message)
    end;
 
-The macro :macro:`with-curl-easy` handles both initialization and
-automatic cleanup when it is no longer accessible. If initialization
-fails, a :class:`<curl-init-error>` exception is raised.
-
 Setting Parameters
 ^^^^^^^^^^^^^^^^^^
 
@@ -87,19 +93,36 @@ handled either immediately at the point of the operation or deferred
 to another method for centralized error handling.
 
 .. code-block:: dylan
-   :caption: In Dylan errors can be captured in a block somewhere.
+   :caption: In Dylan errors can be captured in a block.
 
-   with-curl-easy (curl)
-     curl.curl-url := "https://example.com";
-   end;
+   block ()
+     with-curl-easy (curl = make(<curl-easy>))
+       curl.curl-url := "https://example.com";
+       // perform request
+       // gather information
+     end;
+   exception (err :: <curl-option-error>)
+     format-err("Error setting option: %s\n",
+                 err.curl-error-message)
+   end block;
+
+If you need to set a lot of options, you can pass them to the
+:macro:`with-curl-easy` with less verbosity.
 
-   ...
+.. code-block:: dylan
 
    block ()
-     // somewhere in the code an option is incorrect
-     // and is handled here
+     with-curl-easy (curl = make(<curl-easy>),
+                     url = "https://example.org",
+                     ssl-verifypeer = #f,
+                     ssl-verifyhost = 1,
+                     ca-cache-timeout = 604800)
+       // perform request
+       // gather information
+     end with-curl-easy;
    exception (err :: <curl-option-error>)
-     format-err("Error setting option: %s\n", err.curl-error-message)
+     format-err("Error setting option: %s\n",
+                 err.curl-error-message)
    end block;
 
 Performing the Request
@@ -125,11 +148,12 @@ In Opendylan :func:`curl-perform` raises a
 .. code-block:: dylan
    :caption: Dylan example
 
-   block ()
+   block () 
      curl-easy-perform(curl);
      format-out("Request completed successfully.\n")
    exception (err :: <curl-perform-error>)
-      format-err("Curl failed: %s\n", curl.curl-error-message)
+      format-err("Curl failed: %s\n",
+                  curl.curl-error-message)
    end block;
 
 Retrieving Information
@@ -166,11 +190,11 @@ wrapper, you access the information directly using property syntax.
    :caption: Dylan Example
 
    block ()
-      with-curl-easy (curl)
-        curl.curl-url := "https://example.com/";
+      with-curl-easy (curl = make(<curl>),
+                      url = "https://example.com/")
         curl-easy-perform(curl);
         format-out("Time: %d", curl.total-time)
-      end
+      end;
    exception (err :: <curl-info-error>)
       format-err("curl easy getinfo failed: %s\n",
                  err.curl-error-message)

documentation/source/reference.rst

@@ -153,22 +153,36 @@ Macros
 
    :macrocall:
      .. parsed-literal::
-	with-curl-easy (*name*) body end
+        with-curl-easy (*variable* = *expression*, *option* = *value*, ...) body end
 
    :example:
 
      .. code-block:: dylan
+        :caption: Simple macro form
 
-        with-curl-easy (curl)
-          curl.url := "example.com";
-	  curl-easy-perform(curl);
-	end;
+        with-curl-easy (curl = make(<curl-easy>))
+          curl.curl-url := "http://example.com";
+          curl-easy-perform(curl);
+        end;
+
+   :example:
+    
+     .. code-block:: dylan
+        :caption: Passing options to macro
+
+        with-curl-easy (curl = make(<curl-easy>),
+                        url = "http://example.com",
+                        verbose = #t)
+          curl-easy-perform(curl);
+        end;
 
    :signals:
 
       :class:`<curl-init-error>` if the curl handle could not be
       initialized.
 
+      :class:`<curl-option-error>` if an option is incorrect.
+
    :discussion:
 
      This macro is more or less equivalent to:
@@ -214,7 +228,7 @@ Macros
 
         with-curl-global ($curl-global-all)
           with-curl-easy (curl)
-            curl.url := "https://example.com";
+            curl.curl-url := "https://example.com";
             curl-easy-perform(curl);
 	    // do staff
           end;

src/curl-easy-module.dylan

@@ -342,6 +342,8 @@ define module curl-easy
     $curl-progress-callback;
 
   // Curl options
+  create
+    *curl-options*;
 
   create
     <curlopt-stringpoint>,
@@ -731,9 +733,11 @@ end module curl-easy;
 
 define module curl-easy-impl
   use curl-easy;
-
+  
   use common-dylan;
   use c-ffi;
+  use format;
+  use format-out;
 
   export
     *curl-library-initialized?*;

src/curl-easy.dylan

@@ -524,8 +524,8 @@ define macro with-curl-global
          block ()
            ?body
          cleanup
-	   curl-library-cleanup()
-	 end block }
+           curl-library-cleanup()
+         end block }
 end macro;
 
 define C-function curl-slist-append
@@ -548,18 +548,28 @@ define C-function curl-version
   c-name: "curl_version";
 end C-function;
 
+define macro set-curl-options
+   { set-curl-options (?curl:variable) }
+     => { ?curl }
+   { set-curl-options (?curl:variable, ?option:name = ?value:expression, ?more:*) }
+     => { "curl-" ## ?option ## "-setter"(?value, ?curl);
+          set-curl-options(?curl, ?more) }
+end macro set-curl-options;
+
 define macro with-curl-easy
-  { with-curl-easy (?curl:name) ?body:body end }
-    => { let ?curl = #f;
+  { with-curl-easy (?curl:variable = ?handler:expression, ?options:*) ?body:body end }
+    => { let _curl = #f;
          block ()
-	   ?curl := make(<curl-easy>);
-	   ?body
-	 cleanup
-	   if (?curl)
-	     curl-easy-cleanup(?curl)
-	   end;
+           _curl := ?handler;
+           let ?curl :: <curl-easy> = _curl;
+           set-curl-options(?curl, ?options);
+           ?body
+         cleanup
+           if (_curl)
+             curl-easy-cleanup(_curl)
+           end;
          end block }
-end macro;
+end macro with-curl-easy;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -884,11 +894,15 @@ define constant $curlopttype-boolean       = $curlopttype-long;
 //
 //////////////////////////////////////////////////////////////////////////////
 
+define variable *curl-options* = 0;
+
 define macro curlopt-definer
   { define curlopt ?type:name ?id:name = ?number:expression }
     => { define constant "$curlopt-" ## ?id
            = "$curlopttype-" ## ?type + ?number;
 
+         *curl-options* := *curl-options* + 1;
+
          define method "curl-" ## ?id ## "-setter"
              (option :: "<curlopt-" ## ?type ## ">", curl :: <curl-easy>)
 	  => (option :: "<curlopt-" ## ?type ## ">")

src/library.dylan

@@ -7,4 +7,5 @@ define library dylan-curl
 
   use common-dylan;
   use c-ffi;
+  use io;
 end library;

tests/test-chkspeed.dylan

@@ -19,19 +19,19 @@ define test test-chkspeed (tags: #("io", "slow"))
 	  0
 	end;
   let url = "http://ipv4.download.thinkbroadband.com";
+  let filename = "5MB.zip";
   block () 
     with-curl-global ($curl-global-default)
-      with-curl-easy (curl)
-	let filename = "5MB.zip";
-	curl.curl-url := concatenate(url, "/", filename);
-	curl.curl-useragent := "dylan-curl-speedchecker/1.0";
-	curl.curl-writefunction := $curl-write-callback;
-	curl.curl-xferinfofunction := $curl-progress-callback;
-	curl.curl-noprogress := #f;
-	with-open-file (stream = filename, direction: #"output", if-exists: #"replace")
-	  dynamic-bind(*curl-write-callback* = handle-download)
-	    dynamic-bind(*curl-progress-callback* = progress-callback)
-	      register-c-dylan-object(stream);
+      with-curl-easy (curl = make(<curl-easy>),
+	                    url = concatenate(url, "/", filename),
+	                    useragent = "dylan-curl-speedchecker/1.0",
+	                    writefunction = $curl-write-callback,
+	                    xferinfofunction = $curl-progress-callback,
+	                    noprogress = #f)
+	      with-open-file (stream = filename, direction: #"output", if-exists: #"replace")
+	        dynamic-bind(*curl-write-callback* = handle-download)
+	          dynamic-bind(*curl-progress-callback* = progress-callback)
+	            register-c-dylan-object(stream);
               curl.curl-writedata := export-c-dylan-object(stream);
               curl-easy-perform(curl);
               unregister-c-dylan-object(stream);

tests/test-debug-callback.dylan

@@ -36,12 +36,12 @@ end function;
 define test test-debug-callback (tags: #("io"))
   block ()
     with-curl-global ($curl-global-default)
-      with-curl-easy (curl)
+      with-curl-easy (curl = make(<curl-easy>),
+	                    url = "https://example.com/",
+	                    verbose = #t,  // verbose to use debug-callback
+	                    debugfunction = $curl-debug-callback)
         dynamic-bind (*curl-debug-callback* = dump-debug-callback)
-	  curl.curl-url := "https://example.com/";
-          curl.curl-verbose := #t;  // verbose to use debug-callback
-          curl.curl-debugfunction := $curl-debug-callback;
-          curl-easy-perform(curl);
+	        curl-easy-perform(curl);
         end dynamic-bind;
         assert-true(#t);
       end with-curl-easy;

tests/test-escape-unescape.dylan

@@ -4,7 +4,7 @@ Copyright: Copyright (C) 2025, Dylan Hackers. All rights reserved.
 
 define test test-curl-easy-escape ()
   with-curl-global ($curl-global-default)
-    with-curl-easy (curl)
+    with-curl-easy (curl = make(<curl-easy>))
       let data = "data to convert";
       let expected = "data%20to%20convert";
       let output1 = curl-easy-escape(curl, data, length: 15);
@@ -17,18 +17,18 @@ end test;
 
 define test test-curl-easy-unescape () 
   with-curl-global ($curl-global-default)
-    with-curl-easy (curl)
+    with-curl-easy (curl = make(<curl-easy>))
       let escaped = "%63%75%72%6c";
       let expected = "curl";
       let expected-length = 4;
       let (decoded, decoded-length)
-	= curl-easy-unescape(curl, escaped, length: 12);
+	      = curl-easy-unescape(curl, escaped, length: 12);
       assert-equal(expected, decoded,
 		   "Decoded string is as expected");
       assert-equal(expected-length, decoded-length,
 		   "Decoded length is as expected");
       let (decoded, decoded-length)
-	= curl-easy-unescape(curl, escaped);
+	      = curl-easy-unescape(curl, escaped);
       assert-equal(expected, decoded);
       assert-equal(expected-length, decoded-length);
     end with-curl-easy;

tests/test-get-simple-http-page.dylan

@@ -6,14 +6,14 @@ Copyright: Copyright (C) 2025, Dylan Hackers. All rights reserved.
 
 define test test-get-simple-http-page (tags: #("io"))
   block ()
-    with-curl-global($curl-global-default)
-      with-curl-easy (curl)
-	curl.curl-url := "https://example.com/";
-	curl.curl-followlocation := 1;
-	curl-easy-perform(curl);
-	assert-true(#t);
-      end;
-    end;
+    with-curl-global ($curl-global-default)
+      with-curl-easy (curl = make(<curl-easy>),
+                      url = "https://example.com",
+                      followlocation = 1)
+	      curl-easy-perform(curl);
+	      assert-true(#t);
+      end with-curl-easy;
+    end with-curl-global;
   exception (err :: <curl-error>)
     format-out("Curl failed: %s\n", err.curl-error-message);
   end block;

tests/test-getinfo-cainfo.dylan

@@ -5,11 +5,11 @@ Copyright: Copyright (C) 2025, Dylan Hackers. All rights reserved.
 define test test-getinfo-cainfo () 
   block ()
     with-curl-global ($curl-global-default)
-      with-curl-easy (curl)
-	curl.curl-cainfo := "/etc/ssl/certs/SecureTrust_CA.pem";
-	let cainfo = curl.curl-cainfo;
-	format-out("default ca info path: '%s'\n", cainfo);
-	assert-true(#t);
+      with-curl-easy (curl = make(<curl-easy>),
+                      cainfo = "/etc/ssl/certs/SecureTrust_CA.pem")
+	      let cainfo = curl.curl-cainfo;
+	      format-out("default ca info path: '%s'\n", cainfo);
+	      assert-true(#t);
       end with-curl-easy;
     end with-curl-global;
   exception (err :: <curl-error>)