migrate to tags; make schema type required

Author: niquola

.projectile

@@ -1,19 +1,37 @@
 # zen meta store & schema
 
-## store
+zen project consists of set of namespaces.
+
+On file system namespaces can be organized 
+the same way as java/clojure project.
+
+Each namespace is valid edn file with data,
+describing your models.
+Namespace is a map with two special symbol keys  - 'ns  and 'import
+
+* 'ns - defines name of namespace
+* 'imports - is a set of required namespaces to interpret this namespace (zen namespace is imported implicitly)
+
+Inside namespace you can refer local symbols just by local 
+name or symbols from extrnal namespace by ns-name/sym-name.
+
+All other symbolic keys defines meta-resources.
+
+Symbol may be tagged with keywords. Keywords used to 
+organize and classify symbols.
 
-* namespace
-* resource
+* global keys
 
 ```
-{
- ns myapp.something ;; namespace
- import #{some.ns}
+{ns myapp.something ;; namespace
+ import #{ some.lib }
 
+ :tags {}
+ :desc {}
  ;; resource
- symbol {
+ web {
    ;; name myapp.something/symbol
-   tags #{:zen/schema ....} ;; keyword tags - zen types
+   :zen/tags #{:some.lib/http-server }
 
    ;; resource data
    :key "value"
@@ -27,6 +45,14 @@
 ```
 
 
+
+You can load zen project into meta-storage.
+zen will validate all m
+
+## store
+
+
+
 ## schema
 
 Composable, open-world schema engine.

README.md

@@ -1,78 +1,99 @@
 {ns zen
 
- regex    {types schema
-           tags #{:zen/primitive}
-           :desc "regexp primitive type"
-           :type map
-           :keys {}}
+ :zen/tag {:zen/tags #{:zen/tag}
+           :zen/desc "register keyword as a tag"}
+
+ :zen/schema {:zen/tags #{:zen/tag}
+              :zen/desc "label resource as zen/schema"
+              :schema schema}
+
+ :zen/property {:zen/tags #{:zen/tag}
+                :zen/desc "register tag as a property - i.e. global key with schema"}
+
+ desc {:zen/tags #{:zen/property :zen/schema}
+        :type string}
+
+ name {:zen/tags #{:zen/property :zen/schema}
+       :type symbol}
+
+ ;; ctx {:zen/tags #{:zen/schema}
+ ;;      :zen/desc "schema for meta-store context"
+ ;;      :keys {:tags {:type map :value {:type map :confirms #{tag}}}
+ ;;             :symbols {:type map}}}
+
+ tags {:zen/tags #{:zen/property :zen/schema}
+       :type zen/set
+       :every {:type keyword}}
+
 
- string    {types schema
-            tags #{:zen/primitive}
-            :desc "sring primitive type"
+ string    {:zen/tags #{:zen/primitive :zen/schema}
+            :zen/desc "sring primitive type"
             :type map
             :keys {:minLength {:type integer
                                :min 0
                                :desc "inclusive minimal length of string"}
                    :maxLength {:type integer :min 0}
                    :regex     {:type regex}}}
 
- integer   {types schema
-            tags #{:zen/primitive}
-            :desc "integer primitive type"
+ regex    {:zen/tags #{:zen/schema :zen/primitive}
+           :zen/desc "regexp primitive type"
+           :type map}
+
+
+ integer   {:zen/tags #{:zen/primitive :zen/schema}
+            :zen/desc "integer primitive type"
             :type map
             :keys {:min {:type integer}
                    :max {:type integer}}}
 
- number    {types schema
-            tags #{:zen/primitive}
-            :desc "number primitive type"
+ number    {:zen/tags #{:zen/primitive :zen/schema}
+            :zen/desc "number primitive type"
             :type map
             :keys {:min {:type number}
                    :max {:type number}}}
 
- date      {types schema
-            tags #{:zen/primitive}
+ date      {:zen/tags #{:zen/primitive :zen/schema}
             :type map
             :keys {:in-past   {:type boolean}
                    :in-future {:type boolean}}}
 
- datetime  {types schema
-            tags #{:zen/primitive}
+ datetime  {:zen/tags #{:zen/primitive :zen/schema}
             :type map
             :keys {:in-past {:type boolean}
                    :in-future {:type boolean}}}
 
- boolean   {types schema
-            tags #{:zen/primitive}
+ boolean   {:zen/tags #{:zen/primitive :zen/schema}
             :type map}
 
- symbol    {types schema :type map}
-
- keyword   {types schema :type map}
+ symbol    {:zen/tags #{:zen/primitive :zen/schema}
+            :type map}
 
- union-key {types schema :type map}
+ keyword   {:zen/tags #{:zen/primitive :zen/schema}
+            :type map}
 
+ union-key {:zen/tags #{:zen/primitive :zen/schema}
+            :type map}
 
- coll      {types schema
+ coll      {:zen/tags #{:zen/coll :zen/schema}
             :type map
-            :keys {:every {:confirms #{schema}}
+            :keys {:every {:type map :confirms #{schema}}
                    :minItems {:type integer :min 0}
                    :maxItems {:type integer :min 0}}}
 
- set       {types schema
+ set       {:zen/tags #{:zen/coll :zen/schema}
             :type map
             :confirms #{coll}}
 
- vector    {types schema
+ vector    {:zen/tags #{:zen/coll :zen/schema}
             :type map
             :confirms #{coll}}
 
- map       {types schema
+ map       {:zen/tags #{:zen/coll :zen/schema}
             :type map
-            :keys {:values {:confirms #{schema}}}}
+            :keys {:values {:type map :confirms #{schema}}}}
 
- schema   {types schema
-           :desc "zen schema"
+ schema   {:zen/tags #{:zen/schema}
+           :zen/desc "zen schema"
            :type map
            :schema-key {:key :type}
            :keys {:type {:type symbol}
@@ -90,15 +111,17 @@
                   :require {:type set :every {:type keyword}}}
            :require [:type]}
 
- resource {types schema
+ resource {:zen/tags #{:zen/schema}
            :type map
            :keys {:id {:type string}
                   :resourceType {:type string}}}
 
- reference {types schema
+ reference {:zen/tags #{:zen/schema}
             :type map
             :keys {:id {:type string}
                    :resourceType {:type string}}}
 
- op {types schema
-     :desc "Operaration"}}
+
+ op {:zen/tags #{:zen/schema}
+     :desc "Operaration"
+     :type map}}

pkg/zen.edn

@@ -18,6 +18,9 @@
   (read-ns ctx 'myapp)
   (read-ns ctx 'zen)
 
+
+
+
   (println
    (str/join "\n" (:errors @ctx)))
 

src/zen/core.clj

@@ -8,61 +8,81 @@
 
 (defn update-types-recur [ctx tp-sym sym]
   (swap! ctx update-in [:tps tp-sym] (fn [x] (conj (or x #{}) sym)))
-  (doseq [tp-sym' (get-in @ctx [:syms tp-sym :isa])]
+  (doseq [tp-sym' (get-in @ctx [:symbols tp-sym :isa])]
     (update-types-recur ctx tp-sym' sym)))
 
 (declare read-ns)
 
 (defn pretty-path [pth]
   (->> pth
        (mapv (fn [x] (if (keyword? x) (subs (str x) 1) (str x))))
-       (str/join "." )))
+       (str/join "->" )))
 
-(defn load-ns [ctx nmsps]
+(defn eval-resource [ctx ns-str ns-name nmsps k resource]
+  (-> (clojure.walk/postwalk
+       (fn [x]
+         (if (symbol? x)
+           (if (namespace x)
+             (do (when-not (get-in @ctx [:symbols x])
+                   (swap! ctx update :errors conj (format "Could not resolve symbol '%s in %s/%s" x ns-name k)))
+                 x)
+             (do (when-not (get nmsps x)
+                   (swap! ctx update :errors conj (format "Could not resolve local symbol '%s in %s/%s" x ns-name k)))
+                 (symbol ns-str (name x))))
+           x))
+       resource)
+      (assoc ;;TODO :zen/ns ns-name
+             :zen/name (symbol (name ns-name) (name k)))))
+
+(defn load-tag [ctx nmsps k v]
+  (let [ns-name (get nmsps 'ns)
+        ns-str (name ns-name)
+        res (eval-resource ctx ns-str ns-name nmsps k v)]
+    (swap! ctx (fn [ctx] (update-in ctx [:tags k] (fn [x] (when x (println "WARN: reload tag" (:zen/name res))) res))))))
+
+
+(defn load-symbol [ctx nmsps k v]
   (let [ns-name (get nmsps 'ns)
-        ns-str (name ns-name)]
+        ns-str (name ns-name)
+        sym (symbol ns-str (name k))
+        res (eval-resource ctx ns-str ns-name nmsps k v)]
+    (swap! ctx (fn [ctx] (update-in ctx [:symbols sym] (fn [x] (when x (println "WARN: reload" (:zen/name res))) res))))
+    (doseq [tg (:zen/tags res)]
+      (swap! ctx update-in [:tags-index tg] (fn [x] (conj (or x #{}) sym))))
+    res))
+
+(defn validate-resource [ctx res]
+  (let [tags (get res :zen/tags)
+        tags-reg (get @ctx :tags)
+        schemas (->> tags
+                     (mapv (fn [tag] (get-in tags-reg [tag :schema])))
+                     (filter identity)
+                     (into #{}))]
+    (when-not (empty? schemas)
+      (println "validate with" schemas)
+      (let [{errs :errors} (zen.validation/validate ctx schemas res)]
+        (when-not (empty? errs)
+          (doseq [err errs]
+            (swap! ctx update :errors
+                   conj (format "Validation: %s '%s' in %s by %s"
+                                (get res :zen/name)
+                                (:message err)
+                                (pretty-path (:path err))
+                                (pretty-path (:schema err))))))))))
+
+(defn load-ns [ctx nmsps]
+  (let [ns-name (get nmsps 'ns)]
     (when-not (get-in ctx [:ns ns-name])
       (swap! ctx (fn [ctx] (assoc-in ctx [:ns ns-name] nmsps)))
       (doseq [imp (get nmsps 'import)]
         (read-ns ctx imp))
       (->>
        (dissoc nmsps ['ns 'import])
        (mapv (fn [[k v]]
-              (when (and (symbol? k) (map? v))
-                (let [sym (symbol ns-str (name k))
-                      res (-> (clojure.walk/postwalk
-                               (fn [x]
-                                 (if (and (symbol? x) (not (contains? #{'types} x)))
-                                   (if (namespace x)
-                                     (do (when-not (get-in @ctx [:syms x])
-                                           (swap! ctx update :errors conj (format "Could not resolve symbol '%s in %s/%s" x ns-name k)))
-                                         x)
-                                     (do (when-not (get nmsps x)
-                                           (swap! ctx update :errors conj (format "Could not resolve local symbol '%s in %s/%s" x ns-name k)))
-                                         (symbol ns-str (name x))))
-                                   x))
-                               (dissoc v 'tags 'types))
-                              (assoc 'ns ns-name
-                                     'name (symbol (name ns-name) (name k))
-                                     'types (get 'types v)))]
-                  (swap! ctx (fn [ctx] (assoc-in ctx [:syms sym] res)))
-                  (when-let [tps (get v 'types)]
-                    (assert (or (set? tps) (symbol? tps)) (format "types should be a set of symbols or symbol in %s/%s" ns-name k))
-                    (doseq [tp-sym (if (symbol? tps) [tps] tps)]
-                      (update-types-recur ctx tp-sym sym)))
-                  res))))
-       (mapv (fn [res]
-               (when-let [tps (and res (get res 'types))]
-                 (let [tps (if (symbol? tps) #{tps} tps)]
-                   (let [{errs :errors} (zen.validation/validate ctx tps (dissoc res 'types 'ns 'name 'tags))]
-                     (when-not (empty? errs)
-                       (doseq [err errs]
-                         (swap! ctx update :errors
-                                conj (format "Validation: %s '%s' in %s by %s"
-                                             (get res 'name)
-                                             (:message err)
-                                             (pretty-path (:path err))
-                                             (pretty-path (:schema err)))))))))))))))
+               (cond (keyword? k) (load-tag ctx nmsps k v)
+                     (and (symbol? k) (map? v)) (load-symbol ctx nmsps k v)
+                     :else nil)))
+       (mapv (fn [res] (validate-resource ctx res)))))))
 
 (defn read-ns [ctx nm]
   (let [pth (str (str/replace (str nm) #"\." "/") ".edn")]
@@ -72,7 +92,7 @@
       (swap! ctx update :errors conj (format "Could not load ns '%s" nm)))))
 
 (defn get-symbol [ctx nm]
-  (when-let [res (get-in @ctx [:syms nm])]
+  (when-let [res (get-in @ctx [:symbols nm])]
     (assoc res 'name nm)))
 
 (defn new-context [& [opts]]