ładowanie pliku konfiguracyjnego w clojure jako struktura danych

Question

Czy istnieje funkcja odczytu w clojure do analizy struktury danych clojure? Moim przypadkiem użycia jest odczyt plików właściwości konfiguracji, a jedną wartością dla właściwości powinna być lista. Chciałbym móc napisać to jako:

file.properties:

property1 = ["value1" "value2"] 

oraz w Clojure:

(load-props "file.properties") 

i dostać mapę z wartością {property1 [ "Value1 " "VALUE2"]

teraz, m robię następujące, z tego samego pliku wejściowego "file.properties":

(defn load-props [filename] 
    (let [io (java.io.FileInputStream. filename) 
     prop (java.util.Properties.)] 
    (.load prop io) 
    (into {} prop))) 

;; returns: 
;; {"property1" "[\"valu1\", \"valu2\"]"} 
(load-props "file.properties") 

Ale nie mogę znaleźć sposobu na przeanalizowanie wyniku w wektorze clojure. Zasadniczo szukam czegoś takiego jak plik Erlanga: funkcja konsultacji/1. Masz pomysł, jak to zrobić?

Answer 1

java.util.Properties realizuje Map więc można to zrobić bardzo łatwo, bez ręcznego parsowania właściwości plików:

(require 'clojure.java.io) 
(defn load-props 
    [file-name] 
    (with-open [^java.io.Reader reader (clojure.java.io/reader file-name)] 
    (let [props (java.util.Properties.)] 
     (.load props reader) 
     (into {} (for [[k v] props] [(keyword k) (read-string v)]))))) 

(load-props "test.properties") 
;=> {:property3 {:foo 100, :bar :test}, :property2 99.9, :property1 ["foo" "bar"]} 

W szczególności pliki właściwości są bardziej skomplikowane niż myślisz (komentarze, znaki ucieczki itp. Itp.) I java.util.Properties jest bardzo dobry w ich ładowaniu.

Answer 2

contrib posiada funkcje do odczytywania właściwości pisanie,

http://richhickey.github.com/clojure-contrib/java-utils-api.html#clojure.contrib.java-utils/as-properties

Jeśli jest to dla własnej konsumpcji następnie Proponuję czytanie/pisanie struktur danych clojure można po prostu wydrukować je na dysku i je przeczytać.

Answer 3

(use '[clojure.contrib.duck-streams :only (read-lines)]) 
(import '(java.io StringReader PushbackReader)) 

(defn propline->map [line] ;;property1 = ["value1" "value2"] -> { :property1 ["value1" "value2"] } 
    (let [[key-str value-str] (seq (.split line "=")) 
     key (keyword (.trim key-str)) 
     value (read (PushbackReader. (StringReader. value-str)))] 
     { key value })) 

(defn load-props [filename] 
    (reduce into (map propline->map (read-lines filename)))) 

DEMO

user=> (def prop (load-props "file.properties")) 
#'user/prop 
user=> (prop :property1) 
["value1" "value2"] 
user=> ((prop :property1) 1) 
"value2" 

UPDATE

(defn non-blank? [line] (if (re-find #"\S" line) true false)) 
(defn non-comment? [line] (if (re-find #"^\s*\#" line) false true)) 

(defn load-props [filename] 
    (reduce into (map propline->map (filter #(and (non-blank? %)(non-comment? %)) (read-lines filename))))) 

Answer 4

Czy istnieje funkcja odczytu w clojure do analizy struktury danych clojure?

Tak. Nazywa się read. Możesz także użyć go do odczytu danych konfiguracyjnych.

Plik props.clj zawierający

{:property1 ["value1" 2] 
:property2 {:some "key"}} 

można odczytać tak:

(ns somens.core 
    (:require [clojure.java.io :as io]) 
    (:import [java.io PushbackReader])) 

(def conf (with-open [r (io/reader "props.clj")] 
      (read (PushbackReader. r)))) 

Czytając niezaufanych źródeł może to być dobry pomysł, aby włączyć z *read-eval*:

(def conf (binding [*read-eval* false] 
      (with-open [r (io/reader "props.clj")] 
       (read (PushbackReader. r))))) 

Do zapisania danych konfiguracyjnych z powrotem do pliku powinieneś spojrzeć na p funkcje rint, takie jak pr i przyjaciele.

Answer 5

Jeśli chcesz odczytać pliki właściwości w stylu Java, spójrz na odpowiedź Dave'a Ray'a - choć pliki właściwości mają wiele ograniczeń. Jeśli używasz Clojure 1.5 lub nowszego, sugeruję użycie edn, rozszerzalnej notacji danych używanej w Datomic - to w zasadzie struktury danych clojure, bez wykonywania dowolnego kodu i możliwość dodawania znaczników do rzeczy takich jak instancje lub dowolne typy.

Najprostszym sposobem użycia jest poprzez read-string i slurp:

(require 'clojure.edn) 
(clojure.edn/read-string (slurp "filename.edn")) 

To wszystko. Należy pamiętać, że do odczytu ciąg czyta tylko jedną zmienną, więc należy ustawić konfigurację mapy:

{ :property1 ["value1" "value2"] } 

wówczas:

(require 'clojure.edn) 
(def config (clojure.edn/read-string (slurp "config.edn"))) 
(println (:property1 config)) 

powraca

["value1" "value2"]