Module: KeyTree

Defined in:
lib/key_tree.rb,
lib/key_tree/path.rb,
lib/key_tree/tree.rb,
lib/key_tree/forest.rb,
lib/key_tree/loader.rb,
lib/key_tree/version.rb,
lib/key_tree/meta_data.rb,
lib/key_tree/loader/nil.rb

Overview

Manage a tree of keys

Example:

kt=KeyTree[a: 1, b: { c: 2 }]
kt["a"]
-> 1
kt["b.c"]
-> 2

Defined Under Namespace

Modules: Loader, MetaData Classes: Forest, Path, Tree

Constant Summary collapse

VERSION = 
GVB.version.freeze
DATE = 
GVB.date.freeze

Class Method Summary collapse

Class Method Details

.[](contents = {}) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
 
# File 'lib/key_tree.rb', line 16

def self.[](contents = {})
  case contents
  when Hash
    KeyTree::Tree[contents]
  when Array
    KeyTree::Forest[*contents]
  else
    raise ArgumentError, "can't load #{contents.class} into a KeyTree"
  end
end

.load(type, serialization, prefix: nil) ⇒ Object

Load a KeyTree from some external serialization

load type: serialization load key_prefix, type: serialization

type is upcased to form a class name that should provide a .load class method (like YAML or JSON does).

If a key_prefix is given, it will be prepended to the loaded data.

Examples:

load(:yaml, "---\na: 1\n")

> => 1

load(:yaml, "---\nb: 2\n", prefix: 'a')

> => 2



44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/key_tree.rb', line 44

def self.load(type, serialization, prefix: nil)
  type = type.to_sym unless type.nil?
  loader = Loader[type]
  contents = loader.load(serialization)
  contents = { prefix => contents } unless prefix.nil?

  self[contents].with_meta_data do |meta_data|
    meta_data << { load: { type: type, loader: loader } }
    meta_data << { load: { prefix: prefix } } unless prefix.nil?
  end
end

.load_from_file(file, type, prefix) ⇒ Object 



88
89
90
91
92
93
94
95
 
# File 'lib/key_tree.rb', line 88

def self.load_from_file(file, type, prefix)
  load(type, file.read, prefix: prefix).with_meta_data do |meta_data|
    file_path = file.path
    meta_data << { file: { path: file_path,
                           name: File.basename(file_path),
                           dir: File.dirname(file_path) } }
  end
end

.open(file_name) {|keytree| ... } ⇒ Object

Open an external file and load contents into a KeyTree When the file basename begins with ‘prefix@’, the prefix is prepended to all keys in the filee.

Yields:

  • (keytree) 


59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/key_tree.rb', line 59

def self.open(file_name)
  type = File.extname(file_name)[/[^.]+/]
  prefix = File.basename(file_name)[/(.+)@/, 1]

  keytree = File.open(file_name, mode: 'rb:utf-8') do |file|
    load_from_file(file, type, prefix)
  end

  return keytree unless block_given?
  yield(keytree)
end

.open_all(dir_name, follow_links: false, recurse: false) ⇒ Object

Open all files in a directory and load their contents into a Forest of Trees, optionally following symlinks, and recursing.



73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/key_tree.rb', line 73

def self.open_all(dir_name, follow_links: false, recurse: false)
  Dir.children(dir_name).reduce(KeyTree::Forest.new) do |result, file|
    path = File.join(dir_name, file)
    next result if File.symlink?(path) && !follow_links
    stat = File.stat(path)
    # rubocop:disable Security/Open
    next result << open(path) if stat.file?
    # rubocop:enable Security/Open
    next result unless recurse && stat.directory?
    result << open_all(path, follow_links: follow_links, recurse: true)
  end
end