|
0 |
#--###########################################################
|
|
1 |
# Copyright 2006, Ben Bleything <ben@bleything.net> and #
|
|
2 |
# Patrick May <patrick@hexane.org> #
|
|
3 |
# #
|
|
4 |
# Distributed under the MIT license. #
|
|
5 |
##############################################################
|
|
6 |
#++
|
|
7 |
# See Plist::Emit.
|
|
8 |
module Plist
|
|
9 |
# === Create a plist
|
|
10 |
# You can dump an object to a plist in one of two ways:
|
|
11 |
#
|
|
12 |
# * <tt>Plist::Emit.dump(obj)</tt>
|
|
13 |
# * <tt>obj.to_plist</tt>
|
|
14 |
# * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
|
|
15 |
#
|
|
16 |
# The following Ruby classes are converted into native plist types:
|
|
17 |
# Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
|
|
18 |
# * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
|
|
19 |
# * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
|
|
20 |
# * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
|
|
21 |
#
|
|
22 |
# For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
|
|
23 |
module Emit
|
|
24 |
# Helper method for injecting into classes. Calls <tt>Plist::Emit.dump</tt> with +self+.
|
|
25 |
def to_plist(envelope = true)
|
|
26 |
return Plist::Emit.dump(self, envelope)
|
|
27 |
end
|
|
28 |
|
|
29 |
# Helper method for injecting into classes. Calls <tt>Plist::Emit.save_plist</tt> with +self+.
|
|
30 |
def save_plist(filename)
|
|
31 |
Plist::Emit.save_plist(self, filename)
|
|
32 |
end
|
|
33 |
|
|
34 |
# The following Ruby classes are converted into native plist types:
|
|
35 |
# Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
|
|
36 |
#
|
|
37 |
# Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
|
|
38 |
#
|
|
39 |
# +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
|
|
40 |
#
|
|
41 |
# The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer. Set it to false if you only want the fragment.
|
|
42 |
def self.dump(obj, envelope = true)
|
|
43 |
output = plist_node(obj)
|
|
44 |
|
|
45 |
output = wrap(output) if envelope
|
|
46 |
|
|
47 |
return output
|
|
48 |
end
|
|
49 |
|
|
50 |
# Writes the serialized object's plist to the specified filename.
|
|
51 |
def self.save_plist(obj, filename)
|
|
52 |
File.open(filename, 'wb') do |f|
|
|
53 |
f.write(obj.to_plist)
|
|
54 |
end
|
|
55 |
end
|
|
56 |
|
|
57 |
private
|
|
58 |
def self.plist_node(element)
|
|
59 |
output = ''
|
|
60 |
|
|
61 |
if element.respond_to? :to_plist_node
|
|
62 |
output << element.to_plist_node
|
|
63 |
else
|
|
64 |
case element
|
|
65 |
when Array
|
|
66 |
if element.empty?
|
|
67 |
output << "<array/>\n"
|
|
68 |
else
|
|
69 |
output << tag('array') {
|
|
70 |
element.collect {|e| plist_node(e)}
|
|
71 |
}
|
|
72 |
end
|
|
73 |
when Hash
|
|
74 |
if element.empty?
|
|
75 |
output << "<dict/>\n"
|
|
76 |
else
|
|
77 |
inner_tags = []
|
|
78 |
|
|
79 |
element.keys.sort.each do |k|
|
|
80 |
v = element[k]
|
|
81 |
inner_tags << tag('key', CGI::escapeHTML(k.to_s))
|
|
82 |
inner_tags << plist_node(v)
|
|
83 |
end
|
|
84 |
|
|
85 |
output << tag('dict') {
|
|
86 |
inner_tags
|
|
87 |
}
|
|
88 |
end
|
|
89 |
when true, false
|
|
90 |
output << "<#{element}/>\n"
|
|
91 |
when Time
|
|
92 |
output << tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
|
|
93 |
when Date # also catches DateTime
|
|
94 |
output << tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'))
|
|
95 |
when String, Symbol, Fixnum, Bignum, Integer, Float
|
|
96 |
output << tag(element_type(element), CGI::escapeHTML(element.to_s))
|
|
97 |
when IO, StringIO
|
|
98 |
element.rewind
|
|
99 |
contents = element.read
|
|
100 |
# note that apple plists are wrapped at a different length then
|
|
101 |
# what ruby's base64 wraps by default.
|
|
102 |
# I used #encode64 instead of #b64encode (which allows a length arg)
|
|
103 |
# because b64encode is b0rked and ignores the length arg.
|
|
104 |
data = "\n"
|
|
105 |
Base64::encode64(contents).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
|
|
106 |
output << tag('data', data)
|
|
107 |
else
|
|
108 |
output << comment( 'The <data> element below contains a Ruby object which has been serialized with Marshal.dump.' )
|
|
109 |
data = "\n"
|
|
110 |
Base64::encode64(Marshal.dump(element)).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
|
|
111 |
output << tag('data', data )
|
|
112 |
end
|
|
113 |
end
|
|
114 |
|
|
115 |
return output
|
|
116 |
end
|
|
117 |
|
|
118 |
def self.comment(content)
|
|
119 |
return "<!-- #{content} -->\n"
|
|
120 |
end
|
|
121 |
|
|
122 |
def self.tag(type, contents = '', &block)
|
|
123 |
out = nil
|
|
124 |
|
|
125 |
if block_given?
|
|
126 |
out = IndentedString.new
|
|
127 |
out << "<#{type}>"
|
|
128 |
out.raise_indent
|
|
129 |
|
|
130 |
out << block.call
|
|
131 |
|
|
132 |
out.lower_indent
|
|
133 |
out << "</#{type}>"
|
|
134 |
else
|
|
135 |
out = "<#{type}>#{contents.to_s}</#{type}>\n"
|
|
136 |
end
|
|
137 |
|
|
138 |
return out.to_s
|
|
139 |
end
|
|
140 |
|
|
141 |
def self.wrap(contents)
|
|
142 |
output = ''
|
|
143 |
|
|
144 |
output << '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
|
|
145 |
output << '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
|
|
146 |
output << '<plist version="1.0">' + "\n"
|
|
147 |
|
|
148 |
output << contents
|
|
149 |
|
|
150 |
output << '</plist>' + "\n"
|
|
151 |
|
|
152 |
return output
|
|
153 |
end
|
|
154 |
|
|
155 |
def self.element_type(item)
|
|
156 |
return case item
|
|
157 |
when String, Symbol; 'string'
|
|
158 |
when Fixnum, Bignum, Integer; 'integer'
|
|
159 |
when Float; 'real'
|
|
160 |
else
|
|
161 |
raise "Don't know about this data type... something must be wrong!"
|
|
162 |
end
|
|
163 |
end
|
|
164 |
|
|
165 |
private
|
|
166 |
|
|
167 |
class IndentedString #:nodoc:
|
|
168 |
attr_accessor :indent_string
|
|
169 |
|
|
170 |
@@indent_level = 0
|
|
171 |
|
|
172 |
def initialize(str = "\t")
|
|
173 |
@indent_string = str
|
|
174 |
@contents = ''
|
|
175 |
end
|
|
176 |
|
|
177 |
def to_s
|
|
178 |
return @contents
|
|
179 |
end
|
|
180 |
|
|
181 |
def raise_indent
|
|
182 |
@@indent_level += 1
|
|
183 |
end
|
|
184 |
|
|
185 |
def lower_indent
|
|
186 |
@@indent_level -= 1 if @@indent_level > 0
|
|
187 |
end
|
|
188 |
|
|
189 |
def <<(val)
|
|
190 |
if val.is_a? Array
|
|
191 |
val.each do |f|
|
|
192 |
self << f
|
|
193 |
end
|
|
194 |
else
|
|
195 |
# if it's already indented, don't bother indenting further
|
|
196 |
unless val =~ /\A#{@indent_string}/
|
|
197 |
indent = @indent_string * @@indent_level
|
|
198 |
|
|
199 |
@contents << val.gsub(/^/, indent)
|
|
200 |
else
|
|
201 |
@contents << val
|
|
202 |
end
|
|
203 |
|
|
204 |
# it already has a newline, don't add another
|
|
205 |
@contents << "\n" unless val =~ /\n$/
|
|
206 |
end
|
|
207 |
end
|
|
208 |
end
|
|
209 |
end
|
|
210 |
end
|
|
211 |
|
|
212 |
# we need to add this so sorting hash keys works properly
|
|
213 |
class Symbol #:nodoc:
|
|
214 |
def <=> (other)
|
|
215 |
self.to_s <=> other.to_s
|
|
216 |
end
|
|
217 |
end
|
|
218 |
|
|
219 |
class Array #:nodoc:
|
|
220 |
include Plist::Emit
|
|
221 |
end
|
|
222 |
|
|
223 |
class Hash #:nodoc:
|
|
224 |
include Plist::Emit
|
|
225 |
end
|
|
226 |
|
|
227 |
# $Id: generator.rb 1781 2006-10-16 01:01:35Z luke $
|