new file mode 100644

@@ -0,0 +1,53 @@

+Installation

+============

+

+- Clone this repository somewhere ASDF can find the system: e.g. ```git clone https://github.com/fiddlerwoaroof/cl-edn.git ~/quicklisp/local-projects/cl-edn/```

+- At a REPL, ```(ql:quickload :cl-edn)```

+

+Usage

+=====

+

+This library divides the task of parsing EDN into two stages.  In the

+first stage, implemented by `(EDN:READ-EDN string)` an EDN file is is

+parsed into an AST where primitives are converted into lisp values and

+compound forms are converted into lists of the form 

+`(type-specifier . data)`.  This AST can be passed to 

+`(EDN:SYNTHESIZE implementation ast)` to produce datastructures of a

+specific kind.  The system `cl-edn/fset` provides a synthesizer that

+produces appropriate fset datastructures. The system

+`cl-edn/fset-lossy` produces fset datastructures, but forces symbols

+and keywords to have uppercase names, for easier interoperation with

+CL's default readtable.  As a convenience, there is also 

+`(EDN:PARSE string &optional (implementation 'fset))` that combines

+the two steps into a single call.  These implementations can passed to

+`PARSE` and `SYNTHESIZE` either as the symbols `EDN:FSET` and

+`EDN:FSET-LOSSY` or by instantiating the classes named by those symbols.

+

+EXTENSION

+=========

+

+`EDN:SYNTHESIZE` is a generic function that takes an implementation as

+the first argument. The main system, `CL-EDN`, provides two

+implementations of this function: one that specializes the first

+argument on `SYMBOL`, that just makes an instance of the class named

+by `IMPLEMENTATION` and calls `EDN:SYNTHESIZE` with the instance as

+its first argument; the other implementation inspects the second

+argument and, if it is a list, it delegates to

+`(EDN:SYNTHESIZE-COMPOUND IMPLEMENTATION DISCRIMINATOR ARGS)`, the

+head of the list as `DISCRIMINATOR` and the tail as `ARGS`. The

+default implementation of this generic also provides methods for

+strings, symbols and keywords that produce the relevant lisp types, as

+well as an implementation for tagged literals that implements `#inst`

+and `#uuid` and produces a form `(:TAGGED TAG-SYMBOL DATA)` where

+`DATA` is synthesized according to the rules governing

+`IMPLEMENTATION` (e.g. the `FSET` implementation makes `DATA` to be an

+instance of the datastructures provided by the `FSET` library). Tags

+can also be added to the default implementation by providing an

+EQL-specialized method of `(EDN:SYNTHESIZE-TAG IMPLEMENTATION TAG ARG)`

+for the symbol you want to define a behavior for.  When this method is

+called, the tag-symbol will be uppercased and converted into a common

+lisp keyword and the `ARG` will have been synthesized according to the

+rules provided by `IMPLEMENTATION`.  To override this behavior, an

+implementation can override `EDN:SYNTHESIZE-COMPOUND`, but such

+implementations should either call `CALL-NEXT-METHOD` or implement

+`#inst` and `#uuid` processing themselves.

@@ -8,12 +8,14 @@

   :depends-on (#:alexandria

                #:uiop

                #:serapeum

-               #:smug)

-  :serial t

+               #:smug 

+               :local-time

+               :uuid)

   :in-order-to ((test-op (test-op :cl-edn/test)))

   :components ((:file "package")

-               (:file "edn")

-               (:file "synthesize")))

+               (:file "edn" :depends-on ("package" "synthesize"))

+               (:file "synthesize"

+                      :depends-on ("package"))))

 (defsystem :cl-edn/fset

   :depends-on (#:cl-edn

@@ -336,3 +336,4 @@

 (defun parse (input &optional (realizer 'fset))

   (synthesize realizer

               (read-edn input)))

+

@@ -9,12 +9,6 @@

   and name to match CL's symbol behavior"))

-(defmethod synthesize ((implementation (eql 'fset-lossy)) thing)

-  (typecase thing

-    (list (synthesize-compound implementation (car thing) (cdr thing)))

-    (t thing)))

-

-

 (defmethod synthesize-compound ((implementation fset-lossy) (discriminator (eql :list)) args)

   (mapcar (lambda (a)

             (synthesize implementation a))

@@ -3,13 +3,6 @@

   ()

   (:documentation "An EDN synthesizer that produces fset datastructures"))

-

-(defmethod synthesize ((implementation fset) thing)

-  (typecase thing

-    (list (synthesize-compound implementation (car thing) (cdr thing)))

-    (t thing)))

-

-

 (defmethod synthesize-compound ((implementation fset) (discriminator (eql :map)) args)

   (fset:convert 'fset:map

                 (mapcar (fw.lu:destructuring-lambda ((p k v))

@@ -5,7 +5,9 @@

            :synthesize

            :fset

            :fset-lossy

-           :convert-primitive))

+           :convert-primitive

+           :synthesize-compound

+           :synthesize-tag))

 (defpackage :edn.generate

   (:use :cl)

@@ -5,10 +5,16 @@

 (defgeneric synthesize (implementation args))

 (defgeneric synthesize-compound (implementation discriminator args))

+(defgeneric synthesize-tag (implementation tag args))

 (defmethod synthesize ((implementation symbol) discriminator)

   (synthesize (make-instance 'implementation) discriminator))

+(defmethod synthesize (implementation thing)

+  (typecase thing

+    (list (synthesize-compound implementation (car thing) (cdr thing)))

+    (t thing)))

+

 (defmethod synthesize-compound (implementation (discriminator (eql :keyword)) args)

   (destructuring-bind (ns name) args

     (alexandria:make-keyword (if ns

@@ -39,5 +45,14 @@

       (alexandria:switch ((symbol-name tag) :test 'string-equal)

         ("inst" (local-time:parse-rfc3339-timestring (synthesize implementation obj)))

         ("uuid" (uuid:make-uuid-from-string (synthesize implementation obj)))

-        (t (list :tagged tag

-               (synthesize implementation obj)))))))

+        (t (let ((synthesized-object (synthesize implementation obj)))

+             (fw.lu:if-let* ((tag-keyword (alexandria:make-keyword

+                                           (string-upcase

+                                            (symbol-name tag))))

+                             (methods (compute-applicable-methods

+                                       #'synthesize-tag

+                                       (list implementation tag-keyword synthesized-object))))

+               

+               (synthesize-tag implementation tag-keyword synthesized-object)

+               (list :tagged tag

+                     synthesized-object))))))))

@@ -4,36 +4,39 @@

 (in-package :edn-test)

 (defun float-equal (a b)

-  (> 0.00001

-     (abs (- a b))))

+  (and (typep a (type-of b))

+       (typep b (type-of a))

+       (> 0.00001

+          (abs (- a b)))))

 (deftest floating ()

   (should be float-equal

-          0.1

-          (edn:read-edn "0.1"))

+          0.1d0

+          (edn:read-edn "0.1")

+          )

   (should be float-equal

-          0.1

+          0.1d0

           (edn:read-edn "+0.1"))

   (should be float-equal

-          -0.1

+          -0.1d0

           (edn:read-edn "-0.1"))

   (should be float-equal

-          1

+          1d0

           (edn:read-edn "0.1e1"))

   (should be float-equal

-          1

+          1d0

           (edn:read-edn "0.1e+1"))

   (should be float-equal

-          0.01

+          0.01d0

           (edn:read-edn "0.1e-1"))

   (should be float-equal

-          -0.01

+          -0.01d0

           (edn:read-edn "-0.1e-1"))

   (should be float-equal

-          -0.01

+          -0.01d0

           (edn:read-edn "-0.1e-1M"))

   (should be float-equal

-          -0.0

+          -0.0d0

           (edn:read-edn "-0.e-1M")))

 (deftest edn-parser ()