[#4] Switched to newer reference syntax

deps.edn

@@ -5,8 +5,8 @@
         re-frame                        {:mvn/version "0.10.5"}}
  :paths ["src"]
  :aliases {:figwheel {:extra-paths ["target" "figwheel/resources" "figwheel/src"]
-                      :extra-deps  {com.bhauman/figwheel-main       {:mvn/version "0.1.0"}
+                      :extra-deps  {com.bhauman/figwheel-main       {:mvn/version "0.1.2"}
-                                    com.bhauman/rebel-readline-cljs {:mvn/version "0.1.3"}
+                                    com.bhauman/rebel-readline-cljs {:mvn/version "0.1.4"}
                                     binaryage/devtools              {:mvn/version "0.9.10"}}
                       :main-opts   ["-m" "figwheel.main" "-b" "figwheel/dev" "-r"]}
            :test-clj {:extra-paths ["test"]

examples/resources/extensions/piplette/extension.edn

@@ -4,22 +4,22 @@
   :documentation "..."}
 
  lifecycle
- {:on-activated  [@fetch-all-posts]}
+ {:on-activated  [@events/fetch-all-posts]}
 
  events/fetch-all-posts
- [@ethereum.logs {:address "0xfa28ec7198028438514b49a3cf353bca5541ce1d"
+ [@events/ethereum.logs {:address "0xfa28ec7198028438514b49a3cf353bca5541ce1d"
-                  :topics  ["PeepEth()"]
+                         :topics  ["PeepEth()"]
-                  :inputs  [{:name :hash :type :string}] ;; Allows to decode transaction data
+                         :inputs  [{:name :hash :type :string}] ;; Allows to decode transaction data
-                  :on-log  [@fetch-ipfs]}] ;; A map of decoded data will be injected
+                         :on-log  [@events/fetch-ipfs]}] ;; A map of decoded data will be injected
 
  events/fetch-ipfs
  (let [{:keys [hash]} properties]
-   [@ipfs.get {:hash       hash
+   [@queries/ipfs.get {:hash       hash
-               :on-success [@db.append {:path [:all-posts]}]}])
+                       :on-success [@events/db.append {:path [:all-posts]}]}])
 
  queries/all-posts
- [@db.get {:path  [:all-posts]
+ [@queries/db.get {:path  [:all-posts]
-           :limit 20}]
+                   :limit 20}]
 
  views/post
  ;; TODO get account details
@@ -43,10 +43,10 @@
  {:en "Peepeth !!"}
 
  hooks/main
- [screen {:style @style/screen}
+ [screen {:style @styles/screen}
   [toolbar {}
    [text {}
-    @title]]
+    @i18n/title]]
-  (let [posts @all-posts]
+  (let [posts @queries/all-posts]
    [list {:data     posts
-          :template [@post]}])]}
+          :template [@views/post]}])]}

figwheel/resources/public/assets/extensions/demo/extension.edn

@@ -6,12 +6,12 @@
  :hooks/main
  {:name        ""
   :description ""
-  :view        #status/view [:views/main]}
+  :view        @views/main}
 
  :views/main
  [view {}
   [text {} "Hello"]
-  (let [cond? #status/query [:random-boolean]]
+  (let [cond? @queries/random-boolean]
     (if cond?
       [text {:style {:color "green"}}
        "World?"]

figwheel/src/pluto/figwheel.cljs

@@ -79,6 +79,7 @@
 
 (defn read-extension [o el el-errors]
   (let [{:keys [data errors]} (reader/read (:content (first o)))]
+    (println "data" data)
     (render-extension data el el-errors)))
 
 (defn render-result [{:keys [type value]} el el-errors]

src/pluto/demo.cljs

@@ -1,90 +0,0 @@
-(ns pluto.demo
-  (:require [clojure.string :as string]
-            [pluto.components.html :as html]
-            [pluto.reader :as reader]
-            [pluto.storage :as storage]
-            [pluto.storage.http :as http]
-            [pluto.storage.ipfs :as ipfs]
-            [reagent.core :as reagent]
-            [reagent.dom :as dom]
-            [re-frame.core :as re-frame]
-            [re-frame.loggers :as re-frame.loggers]
-            [devtools.core :as devtools]))
-
-(enable-console-print!)
-(devtools/install!)
-
-(def warn (js/console.warn.bind js/console))
-(re-frame.loggers/set-loggers!
-  {:warn (fn [& args]
-           (cond
-             (= "re-frame: overwriting" (first args)) nil
-             :else (apply warn args)))})
-
-(defonce do-timer (js/setInterval #(re-frame/dispatch [:random (zero? (rand-int 2))]) 1000))
-
-(re-frame/reg-event-db
-  :random
-  (fn [db [_ b]]
-    (assoc db :random b)))
-
-(re-frame/reg-sub
-  :random-boolean
-  :random)
-
-(defn render [h el]
-  (reagent/render h el))
-
-(defn main-hook
-  "A simple hook for :hooks/main"
-  [m]
-  [:div
-   (let [{:views/keys [main]} m]
-     main)])
-
-(defn errors-list [v]
-  [:div
-   [:div "Errors"]
-   (into [:ul]
-     (for [{:keys [type] :as m} v]
-       [:li
-        [:span [:b (str type)] (pr-str (dissoc m :type))]]))])
-
-(defn storage-for [type]
-  (condp = type
-    "url"  (http/HTTPStorage.)
-    "ipfs" (ipfs/IPFSStorage. "https://cors.io/?https://gateway.ipfs.io")))
-
-(defn fetch [uri cb]
-  (let [[type id] (string/split uri ":")]
-    (storage/fetch
-      (storage-for type)
-      {:value id} cb)))
-
-(defn parse [m]
-  (reader/parse {:components       html/components
-                 :valid-extensions #{:extension/meta}
-                 :valid-hooks      #{:hooks/main}}
-                m))
-
-(defn render-extension [m el el-errors]
-  (let [{:keys [data errors]} (parse m)]
-    (when errors
-      (render (errors-list errors) el-errors))
-    (render (main-hook data) el)))
-
-(defn read-extension [o el el-errors]
-  (let [{:keys [data errors]} (reader/read (:content (first o)))]
-    (render-extension data el el-errors)))
-
-(defn render-result [{:keys [type value]} el el-errors]
-  (case type
-    :error (set! (.-innerHTML el-errors) value)
-    (read-extension value el el-errors)))
-
-(defn ^:export load-and-render
-  [s el el-errors]
-  (dom/unmount-component-at-node el)
-  (dom/unmount-component-at-node el-errors)
-  (re-frame/clear-subscription-cache!)
-  (fetch s #(render-result % el el-errors)))

src/pluto/reader.cljc

@@ -15,7 +15,7 @@
     * based on hooks, inject views / trigger events"
   (:refer-clojure :exclude [read])
   (:require [clojure.set              :as set]
-            [clojure.tools.reader.edn :as edn]
+            [clojure.tools.reader     :as reader]
             [pluto.reader.blocks      :as blocks]
             [pluto.reader.reference   :as reference]
             [pluto.utils              :as utils]))
@@ -44,12 +44,10 @@
     (merge
       {:data
        (try
-         (edn/read-string {:default #(do (accumulate-reader-error! errors {:type :unknown-tag :tag %1 :value %2}) %2)
+         #?(:clj   (binding [reader/*read-eval* false]
-                           :readers {'status/query #(reference/create :query %)
+                     (reader/read-string {} s))
-                                     'status/event #(reference/create :event %)
+             :cljs (reader/read-string {} s))
-                                     'status/view  #(reference/create :view %)
+
-                                     'status/style #(reference/create :style %)}}
-                          s)
          (catch #?(:clj Exception :cljs :default) e
            (accumulate-reader-exception! errors e)
            nil))}
@@ -117,7 +115,7 @@
     * :errors a collection of errors"
   (fn [_ k _] (namespace k)))
 
-(defmethod parse-value "hooks" [opts _ v] v)
+(defmethod parse-value "hooks" [_ _ v] v)
 
 (defmethod parse-value "views" [opts _ v] (parse-view opts v))
 
@@ -151,4 +149,4 @@
   (let [errors (validate-keys opts (keys m))]
     (merge-errors (reduce-kv #(merge-parsed-value opts %1 %2 %3) {} m)
                   errors)))
-;; TODO replace all refs to query, event and view here
+;; TODO replace all refs to query, event and view here

src/pluto/reader/blocks.cljc

@@ -10,7 +10,7 @@
 (defn resolve-query [o]
   (cond
     (reference/reference? o)
-    @(re-frame/subscribe (:value o))))
+    @(re-frame/subscribe [(keyword (name (second o)))])))
 
 (defn resolve-queries [env]
   (reduce-kv #(assoc %1 %2 (resolve-query %3))

src/pluto/reader/errors.cljc

@@ -0,0 +1,20 @@
+(ns pluto.reader.errors
+  "
+  Inspired by https://github.com/cognitect-labs/anomalies and https://github.com/dawcs/anomalies-tools"
+  (:require [clojure.spec.alpha :as s]))
+
+(s/def ::category #{::unknown-type
+                    ::interrupted
+                    ::incorrect
+                    ::forbidden
+                    ::unsupported
+                    ::not-found
+                    ::conflict
+                    ::fault
+                    ::busy})
+(s/def ::message string?)
+(s/def ::error (s/keys :req [::type ::value]
+                       :opt [::message]))
+
+(defn error [type o m]
+  (assoc m ::type type ::value o))

src/pluto/reader/reference.cljc

@@ -1,13 +1,9 @@
 (ns pluto.reader.reference
   (:refer-clojure :exclude [resolve]))
 
-;; Record used to track references identified by a set of predefined tag literal
+(defn reference? [o]
-
+  (and (list? o)
-(defrecord Reference [type value])
+       (= 'clojure.core/deref (first o))))
-
-(defn create [type value] (Reference. type value))
-
-(defn reference? [o] (instance? Reference o))
 
 (defmulti resolve
           ""

test/pluto/reader_test.cljc

@@ -1,31 +1,28 @@
 (ns pluto.reader-test
+  (:refer-clojure :exclude [read])
   (:require [clojure.test :refer [is deftest]]
             [pluto.reader :as reader]
-            [pluto.reader.reference :refer [Reference]]
             [pluto.reader.blocks :as blocks]))
 
 (deftest read
   (is (= {:data nil} (reader/read "")))
   (is (= {:data nil :errors [{:type :reader-exception :ex-kind :eof :message "Unexpected EOF while reading item 0 of vector."}]} (reader/read "[")))
-  (is (= {:data [] :errors [{:type :unknown-tag :tag 'unknown, :value []}]}
+  (is (= {:data nil :errors [{:type :reader-exception :ex-kind :reader-error :message "No reader function for tag unknown."}]}
          (reader/read "#unknown []")))
-  (is (= {:data (Reference. :query [])}
+  (is (= {:data {:extension/main '@view/main
-         (reader/read "#status/query []")))
-  (is (= {:data {:extension/main (Reference. :view [:main])
                  :views/main     ['view {}
                                   ['text "Hello"]
-                                  (list 'let ['cond? (Reference. :query [:random-boolean])]
+                                  (list 'let ['cond? '@query/random-boolean]
                                     (list 'when 'cond?
                                       ['text {}
                                        "World"]))]}}
          (reader/read
-           "{:extension/main
+           "{:extension/main @view/main
-              #status/view [:main]
 
              :views/main
               [view {}
                 [text \"Hello\"]
-                  (let [cond? #status/query [:random-boolean]]
+                  (let [cond? @query/random-boolean]
                     (when cond?
                       [text {}
                         \"World\"]))]}"))))
@@ -48,8 +45,6 @@
          (reader/parse {:components {'text :text}} {:views/main ['text {} "Hello"]})))
   (is (= {:data {:views/main [:text {} "Hello"]}}
          (reader/parse {:components {'text :text}} {:views/main ['text {} "Hello"]}))))
-#_
-(not (= {:data {:views/main nil}} :errors ({:type :unsupported-type, :value "string", :key :views/main}) {:data {:views/main nil}, :errors ({:type :unsupported-type, :value "string", :key :views/main})}))
 
 (deftest parse-blocks
   (is (=  {:data {:views/main [blocks/let-block {:env {'s "Hello"}} [:text {} 's]]}}