wip: feat: org-element specs

doerg/src/net/deertopia/doerg/element.clj

@@ -209,6 +209,22 @@
      :first-section-nodes of-first-section
      :rest remaining-nodes*}))
 
+(defn- element-bounds [& nodes]
+  (reduce (fn [acc {:keys [contents-begin contents-end]}]
+            (if (and (nat-int? contents-begin)
+                     (nat-int? contents-end))
+              (-> acc
+                  (update
+                   :contents-begin
+                   #(min (or % Integer/MAX_VALUE) contents-begin))
+                  (update
+                   :contents-end
+                   #(max (or % Integer/MIN_VALUE) contents-end)))
+              acc))
+          {:contents-begin nil
+           :contents-end nil}
+          nodes))
+
 (defn gather-first-section [node]
   (assert (of-type? node "org-data")
           "`gather-doerg-data` should be applied to the document root.")
@@ -216,9 +232,11 @@
         (split-sections (:children node))
         ;; TODO: Construct `:contents-begin` and `:contents-end` data
         ;; by spanning the children.
+        first-section (merge {:type "section"
+                              :children first-section-nodes}
+                             (apply element-bounds first-section-nodes))
         new-children (concat top-level-nodes
-                             (list {:type "section"
-                                    :children first-section-nodes})
+                             (list first-section)
                              rest)]
     (assoc node :children new-children)))
 
@@ -242,15 +260,6 @@
   ([predator prey & more-prey]
    (reduce swallow predator (cons prey more-prey))))
 
-(comment
-  (-> [1 2 3 4]
-      (neighbourly-mapcat prn) )
-  (def doc (read-string (slurp some-org-file)))
-
-  (let [r (atom [])
-        blah]
-    @r))
-
 (defn gather-latex-paragraphs [node]
   (->> node
        (sp/transform
@@ -332,19 +341,13 @@
 (s/def ::contents-begin nat-int?)
 (s/def ::contents-end nat-int?)
 
-(defmulti object-spec :type)
-(defmulti recursive-object-spec :type)
-(defmulti element-spec :type)
-(defmulti greater-element-spec :type)
+(defmulti node-spec :type)
 
 (defn- unimplemented-spec [x]
   (lr/warnf "unimplemented method for %s" (:type x))
   any?)
 
-(defmethod object-spec :default [x] (unimplemented-spec x))
-(defmethod recursive-object-spec :default [x] (unimplemented-spec x))
-(defmethod greater-element-spec :default [x] (unimplemented-spec x))
-(defmethod element-spec :default [x] (unimplemented-spec x))
+(defmethod node-spec :default [x] (unimplemented-spec x))
 
 (def ^:private nfe
   "NFE — “no further expectations.” Used in sub-specs of `::element`
@@ -354,27 +357,33 @@
     (constantly (gen/return {}))))
 
 (s/def ::object
-  (s/multi-spec object-spec :type))
+  (dict {:type string?}))
 
 (s/def ::element
-  (s/merge (dict ^:opt {:contents-begin ::contents-begin
-                        :contents-end ::contents-end}
-                 {:children (s/coll-of ::object :kind vector?)})
-           (s/multi-spec element-spec :type)))
-
-(s/def ::greater-element
-  (s/merge (dict {:contents-begin ::contents-begin
-                  :contents-end ::contents-end
-                  :children (s/coll-of
-                             (s/or :element ::element
-                                   :greater-element ::greater-element)
-                             :kind vector?)})
-           (s/multi-spec greater-element-spec :type)))
-
-(s/def ::recursive-object-base
   (dict ^:opt {:contents-begin ::contents-begin
                :contents-end ::contents-end}
-        {:children (s/coll-of ::object-base :kind vector?)}))
+        {:children (s/coll-of nfe :kind vector?)
+         :type string?}))
+
+(s/def ::node nil)
+
+(s/def ::greater-element
+  (dict {:contents-begin ::contents-begin
+         :contents-end ::contents-end
+         :children (s/coll-of ::node :kind vector?)
+         :type string?}))
+
+(s/def ::recursive-object
+  (dict ^:opt {:contents-begin ::contents-begin
+               :contents-end ::contents-end}
+        {:children (s/coll-of ::node :kind vector?)}))
+
+(s/def ::node (s/multi-spec node-spec :type))
+
+(comment
+  (use 'net.deertopia.doerg.repl)
+  (def doc (-> some-org-file slurp read-string))
+  (s/explain ::node doc))
 
 (s/def ::todo-keyword string?)
 (s/def ::priority string?)
@@ -387,26 +396,29 @@
 
 (def ^:private string-value (dict {:value string?}))
 
-(defmethod object-spec "text" [_] string-value)
-(defmethod object-spec "verbatim" [_] string-value)
-(defmethod object-spec "code" [_] string-value)
-(defmethod recursive-object-spec "bold" [_] nfe)
-(defmethod recursive-object-spec "italic" [_] nfe)
+(defmethod node-spec "text" [_] (s/merge ::object string-value))
+(defmethod node-spec "verbatim" [_] (s/merge ::object string-value))
+(defmethod node-spec "code" [_] (s/merge ::object string-value))
+(defmethod node-spec "bold" [_] ::recursive-object)
+(defmethod node-spec "italic" [_] ::recursive-object)
 
 
 ;;; Specs (specific elements)
 
-(defmethod element-spec "headline" [_]
-  (dict {:todo-keyword (s/nilable ::todo-keyword)
-         :priority (s/nilable ::priority)
-         :level ::level
-         :commented ::commented
-         :raw-value string?
-         :tags ::tags}))
+(defmethod node-spec "headline" [_]
+  (s/merge ::element
+           (dict {:todo-keyword (s/nilable ::todo-keyword)
+                  :priority (s/nilable ::priority)
+                  :level ::level
+                  :commented ::commented
+                  :raw-value string?
+                  :tags ::tags})))
 
 
 ;;; Specs (specific greater elements)
 
-(defmethod greater-element-spec "org-data" [_] nfe)
+(defmethod node-spec "org-data" [_]
+  ::greater-element)
 
-(defmethod greater-element-spec "section" [_] nfe)
+(defmethod node-spec "section" [_]
+  ::greater-element)