lancepantz / clj-yaml

YAML encoding and decoding for Clojure via SnakeYAML

Deprecation

This library is no longer maintained. An actively developed fork is suggested.

Historical README

clj-yaml provides YAML encoding and decoding for Clojure via the SnakeYAML Java library.

Usage

(require '[clj-yaml.core :as yaml])

(yaml/generate-string
  [{:name "John Smith", :age 33}
   {:name "Mary Smith", :age 27}])
"- {name: John Smith, age: 33}\n- {name: Mary Smith, age: 27}\n"

(yaml/parse-string "
- {name: John Smith, age: 33}
- name: Mary Smith
  age: 27
")
=> ({:name "John Smith", :age 33}
    {:name "Mary Smith", :age 27})

Installation

clj-yaml is available as a Maven artifact from Clojars:

:dependencies
  [["clj-yaml" "0.4.0"]
   ...]

Development

$ git clone git://github.com/lancepantz/clj-yaml.git
$ lein deps
$ lein test
$ lein install

clj-yaml's Issues

serialized !!clojure.lang.Symbol has no content

(clj-yaml.core/generate-string {:x :y :a "b"} :dumper-options {:flow-style :flow})
;= "{x: y, a: b}\n"

(clj-yaml.core/generate-string {:x :y :a "b"} :dumper-options {:flow-style :block})
;= "x: y\na: b\n"

(clj-yaml.core/generate-string {:x :y :a 'b} :dumper-options {:flow-style :flow})
;= "{x: y, a: !!clojure.lang.Symbol {}}\n"

(clj-yaml.core/generate-string {:x :y :a 'b} :dumper-options {:flow-style :block})
;= "x: y\na: !!clojure.lang.Symbol {}\n"

Suggest owainlewis/yaml as alternative?

It looks like this library isn't actively maintained anymore. I'd suggest looking at https://github.com/owainlewis/yaml as an alternative.

Reflection Warnings

Reflection warning, clj_yaml/core.clj:19 - call to dump can't be resolved.
Reflection warning, clj_yaml/core.clj:34 - call to load can't be resolved.

No license

There's no statement of license in the source tree or documentation. The default license in most countries does not allow for free use.

can deserialize a Set, but can't serialize a Set

;; works:

(def typed-data-yaml "
the-bin: !!binary 0101")

(clj-yaml.core/parse-string typed-data-yaml)
;= {:the-bin #<byte[] [B@61911e64>}

(clj-yaml.core/generate-string
  (clj-yaml.core/parse-string typed-data-yaml)
  :dumper-options {:flow-style :block})
;= "the-bin: !!binary |-\n  0101\n"


;; generate-string creates a sequence instead of a set:

(def set-yaml "
--- !!set
? Mark McGwire
? Sammy Sosa
? Ken Griff")

(clj-yaml.core/parse-string set-yaml)
;= #{"Mark McGwire" "Ken Griff" "Sammy Sosa"}

(clj-yaml.core/generate-string
  (clj-yaml.core/parse-string set-yaml)
  :dumper-options {:flow-style :block})
;= "- Mark McGwire\n- Ken Griff\n- Sammy Sosa\n"

(clj-yaml.core/parse-string
  (clj-yaml.core/generate-string
    (clj-yaml.core/parse-string set-yaml)
    :dumper-options {:flow-style :block}))
;= ("Mark McGwire" "Ken Griff" "Sammy Sosa")

feature request: optional parameters for primitives

Perhaps something like {:native-keywords true :native-symbols true :native-vectors false}

• With native keywords and symbols:

=>  (println (yaml-dump ['a/b/c :d/e/f (symbol "stuff and/or things") (keyword "other and/or widgets")]))

---
- !!clojure.lang.Symbol
  name: c
  namespace: a/b
- !!clojure.lang.Keyword
  name: f
  namespace: d/e
  sym:
    name: f
    namespace: d/e
- !!clojure.lang.Symbol
  name: or things
  namespace: stuff and
- !!clojure.lang.Keyword
  name: or widgets
  namespace: other and
  sym:
    name: or widgets
    namespace: other and
...

• With common denominator:

  clojure.lang.Keyword
  (encode [data]
    (.substring (str data) 1))

  clojure.lang.Symbol
  (encode [data]
    (str data))

=> (println (yaml-dump ['a/b/c :d/e/f (symbol "stuff and/or things") (keyword "other and/or widgets")]))

---
- a/b/c
- d/e/f
- stuff and/or things
- other and/or widgets
...

(Encoding style similar to cheshire: https://github.com/dakrone/cheshire/blob/6d78a56929f3cb4e925e2d09617465314d3114ba/src/cheshire/generate.clj#L134 )

Upgrade snakeyaml dependency to [org.yaml/snakeyaml "1.17"]

being able to do (yaml/parse-string "\uFFFD � ") without yaml parsing exploding would be nice

feature request: dump/load preferred over parse/generate

"Dump" and "Load" are idiomatic methods within YAML (including SnakeYAML), see:

• http://yaml.org/spec/current.html#id2504671
• http://pyyaml.org/wiki/PyYAMLDocumentation
• http://ruby-doc.org/stdlib-2.0/libdoc/yaml/rdoc/YAML.html#label-Usage

Problem with maps using integer keys

(yaml/generate-string {46 "MAYBE" 52 "DEFINITELY"})
"{46: MAYBE, 52: DEFINITELY}\n"

(yaml/parse-string (yaml/generate-string {46 "MAYBE" 52 "DEFINITELY"}))
{nil "DEFINITELY"}

This seems to be legal YAML, and SnakeYAML itself seems to handle it AFAICT.

Enable decode of java.util.ArrayList as vector instead of list

If replacing the current behavior is acceptable, then the change is

java.util.ArrayList
  (decode [data]
    (mapv decode data))

If replacing current behavior isn't acceptable, then provide a way to optionally select this behavior...