Class: Vines::Storage::Local

Inherits:
Vines::Storage show all
Defined in:
lib/vines/storage/local.rb

Overview

A storage implementation that persists data to YAML files on the local file system.

Instance Method Summary collapse

Methods inherited from Vines::Storage

#authenticate, defer, fiber, from_name, register

Methods included from Log

#log

Constructor Details

#initialize(&block) ⇒ Local

Returns a new instance of Local.



11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/vines/storage/local.rb', line 11

def initialize(&block)
  @dir = nil
  instance_eval(&block)
  unless @dir && File.directory?(@dir) && File.writable?(@dir)
    raise 'Must provide a writable storage directory'
  end

  %w[user vcard fragment room message].each do |sub|
    sub = File.expand_path(sub, @dir)
    Dir.mkdir(sub, 0700) unless File.exists?(sub)
  end
end

Instance Method Details

#delete_offline_messages(jid) ⇒ Object 



57
58
59
60
61
 
# File 'lib/vines/storage/local.rb', line 57

def delete_offline_messages(jid)
  if offline_messages_present?(jid)
    File.delete(absolute_path("message/#{jid.bare.to_s}"))
  end
end

#dir(dir = nil) ⇒ Object 



24
25
26
 
# File 'lib/vines/storage/local.rb', line 24

def dir(dir=nil)
  dir ? @dir = File.expand_path(dir) : @dir
end

#fetch_offline_messages(jid) ⇒ Object 



63
64
65
66
67
 
# File 'lib/vines/storage/local.rb', line 63

def fetch_offline_messages(jid)
  jid = JID.new(jid).bare.to_s        
  file = absolute_path("message/#{jid}") unless jid.empty?        
  offline_msgs = YAML.load_file(file) rescue {}
end

#find_fragment(jid, node) ⇒ Object 



92
93
94
95
96
97
 
# File 'lib/vines/storage/local.rb', line 92

def find_fragment(jid, node)
  jid = JID.new(jid).bare.to_s
  return if jid.empty?
  file = 'fragment/%s' % fragment_id(jid, node)
  Nokogiri::XML(read(file)).root rescue nil
end

#find_user(jid) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/vines/storage/local.rb', line 28

def find_user(jid)
  jid = JID.new(jid).bare.to_s
  file = "user/#{jid}" unless jid.empty?
  record = YAML.load(read(file)) rescue nil
  return User.new(jid: jid).tap do |user|
    user.name, user.password = record.values_at('name', 'password')
    (record['roster'] || {}).each_pair do |jid, props|
      user.roster << Contact.new(
        jid: jid,
        name: props['name'],
        subscription: props['subscription'],
        ask: props['ask'],
        groups: props['groups'] || [])
    end
  end if record
end

#find_vcard(jid) ⇒ Object 



79
80
81
82
83
84
 
# File 'lib/vines/storage/local.rb', line 79

def find_vcard(jid)
  jid = JID.new(jid).bare.to_s
  return if jid.empty?
  file = "vcard/#{jid}"
  Nokogiri::XML(read(file)).root rescue nil
end

#offline_messages_present?(jid) ⇒ Boolean

Returns:

  • (Boolean) 


53
54
55
 
# File 'lib/vines/storage/local.rb', line 53

def offline_messages_present?(jid)
  File.exist?(absolute_path("message/#{jid.bare.to_s}"))
end

#save_fragment(jid, node) ⇒ Object 



99
100
101
102
103
104
 
# File 'lib/vines/storage/local.rb', line 99

def save_fragment(jid, node)
  jid = JID.new(jid).bare.to_s
  return if jid.empty?
  file = 'fragment/%s' % fragment_id(jid, node)
  save(file, node.to_xml)
end

#save_offline_message(msg) ⇒ Object 



69
70
71
72
73
74
75
76
77
 
# File 'lib/vines/storage/local.rb', line 69

def save_offline_message(msg)
  file = "message/#{msg[:to]}"
  offline_msgs = YAML.load_file(absolute_path(file)) rescue []
  msg.delete('to')
  offline_msgs << msg
  save(file) do |f|          
    YAML.dump(offline_msgs,f)
  end
end

#save_user(user) ⇒ Object 



45
46
47
48
49
50
51
 
# File 'lib/vines/storage/local.rb', line 45

def save_user(user)
  record = {'name' => user.name, 'password' => user.password, 'roster' => {}}
  user.roster.each do |contact|
    record['roster'][contact.jid.bare.to_s] = contact.to_h
  end
  save("user/#{user.jid.bare}", YAML.dump(record))
end

#save_vcard(jid, card) ⇒ Object 



86
87
88
89
90
 
# File 'lib/vines/storage/local.rb', line 86

def save_vcard(jid, card)
  jid = JID.new(jid).bare.to_s
  return if jid.empty?
  save("vcard/#{jid}", card.to_xml)
end