Store and load json data.

This simple system can be used to store and retrieve json data.

Usage

Initialization

JsonStore use the file system to store and load json files.

For initialization you need to give the directory used in the file system to save objects.

var store = new JsonStore("store_dir")

Documents

With JsonStore you manage documents. Documents are simple json files that can be stored and loaded from json store.

JsonStore can store documents of type JsonObject and JsonArray.

var red = new JsonObject
red["name"] = "red"
red["code"] = "FF0000"

Data are stored under a key. This is the path to the document from JsonStore::store_dir without the .json extension.

Examples:

  • key document will store data under store_dir / "document.json"
  • key collection/data will store data under store_dir / "collection/data.json"
var key = "colors/red"

Store the object.

store.store_object(key, red)

Load the object.

assert store.has_key(key)
var obj = store.load_object(key)
assert obj["name"] == obj["name"]

Collections

A collection is a set of documents stored under the same path.

var green = new JsonObject
green["name"] = "green"
green["code"] = "00FF00"
store.store_object("colors/green", green)

assert store.has_collection("colors")

var col = store.list_collection("colors")
assert col.length == 2
assert col.has("green")
assert col.has("red")

Clearing store

You can delete all the data contained in the JsonStore::store_dir with clear.

store.clear

Introduced classes

class JsonStore

json :: JsonStore

A JsonStore can save and load json data from file system.

All class definitions

class JsonStore

json $ JsonStore

A JsonStore can save and load json data from file system.
package_diagram json::store store json json json::store->json parser_base parser_base json->parser_base serialization serialization json->serialization ...parser_base ... ...parser_base->parser_base ...serialization ... ...serialization->serialization github::cache cache github::cache->json::store github::github github github::github->github::cache github::github... ... github::github...->github::github

Ancestors

module abstract_collection

core :: abstract_collection

Abstract collection classes and services.
module abstract_text

core :: abstract_text

Abstract class for manipulation of sequences of characters
module array

core :: array

This module introduces the standard array structure.
module bitset

core :: bitset

Services to handle BitSet
module bytes

core :: bytes

Services for byte streams and arrays
module caching

serialization :: caching

Services for caching serialization engines
module circular_array

core :: circular_array

Efficient data structure to access both end of the sequence.
module codec_base

core :: codec_base

Base for codecs to use with streams
module codecs

core :: codecs

Group module for all codec-related manipulations
module collection

core :: collection

This module define several collection classes.
module core

core :: core

Standard classes and methods used by default by Nit programs and libraries.
module engine_tools

serialization :: engine_tools

Advanced services for serialization engines
module environ

core :: environ

Access to the environment variables of the process
module error

json :: error

Intro JsonParseError which is exposed by all JSON reading APIs
module error

core :: error

Standard error-management infrastructure.
module exec

core :: exec

Invocation and management of operating system sub-processes.
module file

core :: file

File manipulations (create, read, write, etc.)
module fixed_ints

core :: fixed_ints

Basic integers of fixed-precision
module fixed_ints_text

core :: fixed_ints_text

Text services to complement fixed_ints
module flat

core :: flat

All the array-based text representations
module gc

core :: gc

Access to the Nit internal garbage collection mechanism
module hash_collection

core :: hash_collection

Introduce HashMap and HashSet.
module inspect

serialization :: inspect

Refine Serializable::inspect to show more useful information
module iso8859_1

core :: iso8859_1

Codec for ISO8859-1 I/O
module kernel

core :: kernel

Most basic classes and methods.
module list

core :: list

This module handle double linked lists
module math

core :: math

Mathematical operations
module meta

meta :: meta

Simple user-defined meta-level to manipulate types of instances as object.
module native

core :: native

Native structures for text and bytes
module numeric

core :: numeric

Advanced services for Numeric types
module parser_base

parser_base :: parser_base

Simple base for hand-made parsers of all kinds
module poset

poset :: poset

Pre order sets and partial order set (ie hierarchies)
module protocol

core :: protocol

module queue

core :: queue

Queuing data structures and wrappers
module range

core :: range

Module for range of discrete objects.
module re

core :: re

Regular expression support for all services based on Pattern
module ropes

core :: ropes

Tree-based representation of a String.
module safe

serialization :: safe

Services for safer deserialization engines
module serialization

serialization :: serialization

General serialization services
module serialization_core

serialization :: serialization_core

Abstract services to serialize Nit objects to different formats
module serialization_read

json :: serialization_read

Services to read JSON: deserialize_json and JsonDeserializer
module serialization_write

json :: serialization_write

Services to write Nit objects to JSON strings: serialize_to_json and JsonSerializer
module sorter

core :: sorter

This module contains classes used to compare things and sorts arrays.
module static

json :: static

Static interface to read Nit objects from JSON strings
module stream

core :: stream

Input and output streams of characters
module text

core :: text

All the classes and methods related to the manipulation of text entities
module time

core :: time

Management of time and dates
module union_find

core :: union_find

union–find algorithm using an efficient disjoint-set data structure
module utf8

core :: utf8

Codec for UTF-8 I/O

Parents

module json

json :: json

Read and write JSON formatted text using the standard serialization services

Children

module cache

github :: cache

Enable caching on Github API accesses.

Descendants

module a_star-m

a_star-m

module github

github :: github

Nit wrapper for Github API
module loader

github :: loader

module pop_auth

popcorn :: pop_auth

Authentification handlers.
module wallet

github :: wallet

Github OAuth tokens management
# Store and load json data.
#
# This simple system can be used to store and retrieve json data.
#
# ## Usage
#
# ### Initialization
#
# JsonStore use the file system to store and load json files.
#
# For initialization you need to give the directory used in the
# file system to save objects.
#
# ~~~
# var store = new JsonStore("store_dir")
# ~~~
#
# ### Documents
#
# With JsonStore you manage *documents*.
# Documents are simple json files that can be stored and loaded from json store.
#
# JsonStore can store documents of type JsonObject and JsonArray.
# ~~~
# var red = new JsonObject
# red["name"] = "red"
# red["code"] = "FF0000"
# ~~~
#
# Data are stored under a *key*.
# This is the path to the document from `JsonStore::store_dir`
# without the `.json` extension.
#
# Examples:
#
# * key `document` will store data under `store_dir / "document.json"`
# * key `collection/data` will store data under `store_dir / "collection/data.json"`
#
# ~~~
# var key = "colors/red"
# ~~~
#
# Store the object.
# ~~~
# store.store_object(key, red)
# ~~~
#
# Load the object.
# ~~~
# assert store.has_key(key)
# var obj = store.load_object(key)
# assert obj["name"] == obj["name"]
# ~~~
#
# ### Collections
#
# A collection is a set of documents stored under the same path.
#
# ~~~
# var green = new JsonObject
# green["name"] = "green"
# green["code"] = "00FF00"
# store.store_object("colors/green", green)
#
# assert store.has_collection("colors")
#
# var col = store.list_collection("colors")
# assert col.length == 2
# assert col.has("green")
# assert col.has("red")
# ~~~
#
# ### Clearing store
#
# You can delete all the data contained in the `JsonStore::store_dir` with `clear`.
#
# ~~~
# store.clear
# ~~~
module store

import static
import json

# A JsonStore can save and load json data from file system.
class JsonStore

	# Directory where data are stored.
	#
	# Directory is created lazilly at the first write.
	var store_dir: String

	# Delete all stored data.
	#
	# Warning: all `JsonStore` instances sharing the same `store_dir` will
	# be cleared.
	fun clear do
		if not store_dir.file_exists then return
		store_dir.rmdir
	end

	# Is there data are stored under `key`.
	fun has_key(key: String): Bool do
		return ("{store_dir}/{key}.json".simplify_path).file_exists
	end

	# Save `json` object under `key`.
	fun store_object(key: String, json: JsonObject) do
		store_json(key, json)
	end

	# Save `json` array under `key`.
	fun store_array(key: String, json: JsonArray) do
		store_json(key, json)
	end

	# Save `json` data under `key`.
	#
	# Only `JsonObject` and `JsonArray` are allowed in a json file.
	# Use `store_object` or `store_array` instead.
	private fun store_json(key: String, json: Serializable) do
		var path = "{store_dir}/{key}.json".simplify_path
		path.dirname.mkdir
		var file = new FileWriter.open(path)
		file.write(json.to_json)
		file.close
	end

	# Load a JsonObject associated to `key` from store.
	fun load_object(key: String): JsonObject do
		return load_json(key).as(JsonObject)
	end

	# Load a JsonArray associated to `key` from store.
	fun load_array(key: String): JsonArray do
		return load_json(key).as(JsonArray)
	end

	# Load a JsonObject associated to `key` from store.
	#
	# Ensure `has_data(key)`
	private fun load_json(key: String): nullable Serializable do
		assert has_key(key)
		var path = "{store_dir}/{key}.json".simplify_path
		var file = new FileReader.open(path)
		var text = file.read_all
		file.close
		return text.parse_json
	end

	# Get the list of keys stored under the collection `key`.
	fun list_collection(key: String): JsonArray do
		var res = new JsonArray
		var coll = ("{store_dir}/{key}".simplify_path).to_path
		if not coll.exists or not coll.stat.is_dir then return res
		for file in coll.files do
			if file.to_s.has_suffix(".json") then
				res.add(file.to_s.basename(".json"))
			end
		end
		return res
	end

	# Does `key` matches a collection?
	fun has_collection(key: String): Bool do
		var path = ("{store_dir}/{key}".simplify_path).to_path
		return path.exists and path.stat.is_dir
	end
end
lib/json/store.nit:11,1--179,3