fix all kibit issues

Author: pavetok

src/naga/cli.clj

@@ -33,14 +33,15 @@
 
 (defn usage
  [{summary :summary}]
- (->> ["Executes Naga on a program."
- ""
- "Usage: naga [filename]"
- ""
- summary
- (str "Store types: " (into [] stores))
- ""]
- (string/join \newline)))
+ (string/join
+ \newline
+ ["Executes Naga on a program."
+ ""
+ "Usage: naga [filename]"
+ ""
+ summary
+ (str "Store types: " (vec stores))
+ ""]))
 
 (defn run-all
  "Runs a program, and returns the data processed, the results, and the stats.
@@ -74,7 +75,6 @@
  :output (remove (set axioms) data)
  :stats stats}))
 
-
 (defn- nm
  "Returns a string version of a keyword. These are not being represented
  as Clojure keywords, so namespaces (when they exist) are separated by
@@ -84,7 +84,6 @@
  (str n ":" (name k))
  (name k)))
 
-
 (defn- predicate-string
  "Convert a predicate triplet into a string."
  [[e p v]]
@@ -95,7 +94,7 @@
 (defn logic-program
  [in-stream]
  (let [{:keys [input output stats]} (run-all in-stream)]
- (println "INPUT DATA") 
+ (println "INPUT DATA")
  (doseq [a input] (println (predicate-string a)))
  (println "\nNEW DATA")
  (doseq [a output] (println (predicate-string a)))))

src/naga/data.clj

@@ -103,8 +103,7 @@
  "Converts parsed JSON into a sequence of triples for a provided storage."
  [storage j]
  (binding [*current-storage* storage]
- (doall (apply concat
- (map ident-map->triples j)))))
+ (doall (mapcat ident-map->triples j))))
 
 
 (s/defn stream->triples :- [Triple]
@@ -184,11 +183,12 @@
  "Uses a set of property-value pairs to load up a nested data structure from the graph"
  [store :- Storage
  prop-vals :- [[s/Keyword s/Any]]]
- (->
+ (dissoc
  (->> prop-vals
  (map (partial recurse-node store))
  (into {}))
- (dissoc :db/id :db/ident)))
+ :db/id
+ :db/ident))
 
 
 (s/defn id->json :- {s/Keyword s/Any}

src/naga/engine.clj

@@ -93,16 +93,16 @@
  ;; the rule was run
  [storage
  (u/mapmap :name (comp deref :execution-count) (vals rules))]
- 
+
 
  ;; find if any patterns have updated
  (if-let [dirty-patterns (seq (keep extract-dirty-pattern
  status))]
  ;; rule needs to be run
  (let [counted-patterns (keep (partial resolve-count storage status)
-  dirty-patterns)
+ dirty-patterns)
 
- counted-set (into #{} counted-patterns)
+ counted-set (set counted-patterns)
 
  hinted-patterns (map #(get counted-set % %) body)]
 
@@ -142,7 +142,6 @@
  {:keys [rules axioms]} :- Program]
  (let [storage (store/get-storage-handle config)
  storage' (store/start-tx storage)
- [output-storage stats] (->> (store/assert-data storage' axioms)
- (execute rules))
+ [output-storage stats] (execute rules (store/assert-data storage' axioms))
  result-storage (store/commit-tx output-storage)]
  [result-storage stats]))

src/naga/lang/basic.clj

@@ -6,7 +6,7 @@
  [the.parsatron :refer :all]
  [naga.schema.structs :as st]))
 
-(defn choice* 
+(defn choice*
  "choice with backtracking."
  [& args]
  (apply choice (map attempt args)))
@@ -73,32 +73,32 @@
 
 (defparser integer []
  (let->> [i (either digits (signed-digits))]
- (always (Long/parseLong (apply str i)))))
+ (always (Long/parseLong (str/join i)))))
 
 (defparser floating-point []
  (let->> [i (either digits (signed-digits))
  f (>> (char \.) (many1 (digit)))]
- (always (Double/parseDouble (apply str (apply str i) \. f)))))
+ (always (Double/parseDouble (apply str (str/join i) \. f)))))
 
 (def number (either* (floating-point) (integer)))
 
 ;; parses strings of the form: 'it''s a string!'
 (defparser pstring1 []
- (let->> [s (many1 (between (char \') (char \') (many non-squote))) ]
- (always (apply str (flatten (interpose \' s))))))
+ (let->> [s (many1 (between (char \') (char \') (many non-squote)))]
+ (always (str/join (flatten (interpose \' s))))))
 
 ;; parses strings of the form: "She said, ""Hello,"" to me."
 (defparser pstring2 []
  (let->> [s (many1 (between (char \") (char \") (many non-dquote)))]
- (always (apply str (flatten (interpose \" s))))))
+ (always (str/join (flatten (interpose \" s))))))
 
 (def pstring (either (pstring1) (pstring2)))
 
 ;; variables start with a capital. Internally they start with ?
 (defparser variable []
  (let->> [f (upper-case-letter)
  r (many (letter))]
- (always (symbol (apply str "?" (Character/toLowerCase f) r) ))))
+ (always (symbol (apply str "?" (Character/toLowerCase f) r)))))
 
 (defn build-keyword
  "Creates a keyword from a parsed word token"
@@ -114,7 +114,7 @@
 ;; atomic values, like a predicate, are represented as a keyword
 (defparser kw []
  (let->> [r ns-word]
- (let [wrd (apply str r)]
+ (let [wrd (str/join r)]
  (if-let [k (build-keyword wrd)]
  (always k)
  (throw (fail (str "Invalid identifier: " wrd)))))))

src/naga/storage/memory/core.clj

@@ -31,7 +31,7 @@
  ([patterns :- [EPVPattern]]
  (let [all-paths (paths #{} patterns)]
  (assert (every? (partial = (count patterns)) (map count all-paths))
- (str "No valid paths through: " (into [] patterns)))
+ (str "No valid paths through: " (vec patterns)))
  all-paths))
  ([bound :- #{Symbol}
  patterns :- [EPVPattern]]
@@ -97,7 +97,7 @@
 (s/defn select-planner
  "Selects a query planner function"
  [options]
- (let [opt (into #{} options)]
+ (let [opt (set options)]
  (case (get opt :planner)
  :user user-plan
  :min min-join-path
@@ -171,7 +171,7 @@
 (extend-protocol Constraint
  ;; EPVPatterns are implemented in vectors
  IPersistentVector
- (get-vars [p] (into #{} (st/vars p)))
+ (get-vars [p] (set (st/vars p)))
 
  (left-join [p results graph] (pattern-left-join graph results p))
 
@@ -276,7 +276,7 @@
  (and (keyword? value)
  (= "mem" (namespace value))
  (str/starts-with? (name value) "node-")))
- 
+
  (data-property [_ data]
  :naga/first)
 
@@ -292,8 +292,7 @@
  (count (mem/resolve-pattern graph pattern))))
 
  (query [_ output-pattern patterns]
- (->> (join-patterns graph patterns)
- (project output-pattern)))
+ (project output-pattern (join-patterns graph patterns)))
 
  (assert-data [_ data]
  (->MemoryStore (add-to-graph graph data)))