| Class | WSDL::SOAP::ClassDefCreator |
| In: |
lib/wsdl/soap/classDefCreator.rb
|
| Parent: | Object |
| DEFAULT_ITEM_NAME | = | XSD::QName.new(nil, 'item') |
# File lib/wsdl/soap/classDefCreator.rb, line 21
21: def initialize(definitions)
22: @elements = definitions.collect_elements
23: @simpletypes = definitions.collect_simpletypes
24: @complextypes = definitions.collect_complextypes
25: @faulttypes = nil
26: if definitions.respond_to?(:collect_faulttypes)
27: @faulttypes = definitions.collect_faulttypes
28: end
29: end
# File lib/wsdl/soap/classDefCreator.rb, line 31
31: def dump(type = nil)
32: result = "require 'xsd/qname'\n"
33: if type
34: result = dump_classdef(type.name, type)
35: else
36: str = dump_element
37: unless str.empty?
38: result << "\n" unless result.empty?
39: result << str
40: end
41: str = dump_complextype
42: unless str.empty?
43: result << "\n" unless result.empty?
44: result << str
45: end
46: str = dump_simpletype
47: unless str.empty?
48: result << "\n" unless result.empty?
49: result << str
50: end
51: end
52: result
53: end
# File lib/wsdl/soap/classDefCreator.rb, line 204
204: def attribute_basetype(attr)
205: if klass = basetype_class(attr.type)
206: klass
207: elsif attr.local_simpletype
208: basetype_class(attr.local_simpletype.base)
209: else
210: nil
211: end
212: end
# File lib/wsdl/soap/classDefCreator.rb, line 214
214: def basetype_class(type)
215: return nil if type.nil?
216: if simpletype = @simpletypes[type]
217: basetype_mapped_class(simpletype.base)
218: else
219: basetype_mapped_class(type)
220: end
221: end
# File lib/wsdl/soap/classDefCreator.rb, line 223
223: def define_attribute(c, attributes)
224: schema_attribute = []
225: attributes.each do |attribute|
226: name = name_attribute(attribute)
227: if klass = attribute_basetype(attribute)
228: type = klass.name
229: else
230: type = nil
231: end
232: methodname = safemethodname('xmlattr_' + name.name)
233: c.def_method(methodname) do "(@__xmlattr ||= {})[\#{dqname(name)}]\n"
234: end
235: c.def_method(methodname + '=', 'value') do "(@__xmlattr ||= {})[\#{dqname(name)}] = value\n"
236: end
237: schema_attribute << [name, type]
238: end
239: c.def_classvar('schema_attribute',
240: '{' +
241: schema_attribute.collect { |name, type|
242: dqname(name) + ' => ' + ndq(type)
243: }.join(', ') +
244: '}'
245: )
246: end
# File lib/wsdl/soap/classDefCreator.rb, line 268
268: def dump_arraydef(complextype)
269: qname = complextype.name
270: c = XSD::CodeGen::ClassDef.new(create_class_name(qname), '::Array')
271: c.comment = "#{qname}"
272: child_type = complextype.child_type
273: c.def_classvar('schema_type', ndq(child_type.name))
274: c.def_classvar('schema_ns', ndq(child_type.namespace))
275: child_element = complextype.find_aryelement
276: schema_element = []
277: if child_type == XSD::AnyTypeName
278: type = nil
279: elsif child_element and (klass = element_basetype(child_element))
280: type = klass.name
281: elsif child_type
282: type = create_class_name(child_type)
283: else
284: type = nil
285: end
286: if child_element
287: if child_element.map_as_array?
288: type << '[]' if type
289: end
290: child_element_name = child_element.name
291: else
292: child_element_name = DEFAULT_ITEM_NAME
293: end
294: schema_element << [child_element_name.name, child_element_name, type]
295: c.def_classvar('schema_element',
296: '[' +
297: schema_element.collect { |varname, name, type|
298: '[' +
299: (
300: if name
301: varname.dump + ', [' + ndq(type) + ', ' + dqname(name) + ']'
302: else
303: varname.dump + ', ' + ndq(type)
304: end
305: ) +
306: ']'
307: }.join(', ') +
308: ']'
309: )
310: c.dump
311: end
# File lib/wsdl/soap/classDefCreator.rb, line 121
121: def dump_classdef(qname, typedef, qualified = false)
122: if @faulttypes and @faulttypes.index(qname)
123: c = XSD::CodeGen::ClassDef.new(create_class_name(qname),
124: '::StandardError')
125: else
126: c = XSD::CodeGen::ClassDef.new(create_class_name(qname))
127: end
128: c.comment = "#{qname}"
129: c.def_classvar('schema_type', ndq(qname.name))
130: c.def_classvar('schema_ns', ndq(qname.namespace))
131: c.def_classvar('schema_qualified', dq('true')) if qualified
132: schema_element = []
133: init_lines = ''
134: params = []
135: typedef.each_element do |element|
136: if element.type == XSD::AnyTypeName
137: type = nil
138: elsif klass = element_basetype(element)
139: type = klass.name
140: elsif element.type
141: type = create_class_name(element.type)
142: else
143: type = nil # means anyType.
144: # do we define a class for local complexType from it's name?
145: # type = create_class_name(element.name)
146: # <element>
147: # <complexType>
148: # <seq...>
149: # </complexType>
150: # </element>
151: end
152: name = name_element(element).name
153: attrname = safemethodname?(name) ? name : safemethodname(name)
154: varname = safevarname(name)
155: c.def_attr(attrname, true, varname)
156: init_lines << "@#{varname} = #{varname}\n"
157: if element.map_as_array?
158: params << "#{varname} = []"
159: type << '[]' if type
160: else
161: params << "#{varname} = nil"
162: end
163: # nil means @@schema_ns + varname
164: eleqname =
165: (varname == name && element.name.namespace == qname.namespace) ?
166: nil : element.name
167: schema_element << [varname, eleqname, type]
168: end
169: unless typedef.attributes.empty?
170: define_attribute(c, typedef.attributes)
171: init_lines << "@__xmlattr = {}\n"
172: end
173: c.def_classvar('schema_element',
174: '[' +
175: schema_element.collect { |varname, name, type|
176: '[' +
177: (
178: if name
179: varname.dump + ', [' + ndq(type) + ', ' + dqname(name) + ']'
180: else
181: varname.dump + ', ' + ndq(type)
182: end
183: ) +
184: ']'
185: }.join(', ') +
186: ']'
187: )
188: c.def_method('initialize', *params) do
189: init_lines
190: end
191: c.dump
192: end
# File lib/wsdl/soap/classDefCreator.rb, line 76
76: def dump_complextype
77: @complextypes.collect { |type|
78: case type.compoundtype
79: when :TYPE_STRUCT, :TYPE_EMPTY
80: dump_classdef(type.name, type)
81: when :TYPE_ARRAY
82: dump_arraydef(type)
83: when :TYPE_SIMPLE
84: dump_simpleclassdef(type)
85: when :TYPE_MAP
86: # mapped as a general Hash
87: nil
88: else
89: raise RuntimeError.new(
90: "unknown kind of complexContent: #{type.compoundtype}")
91: end
92: }.compact.join("\n")
93: end
# File lib/wsdl/soap/classDefCreator.rb, line 57
57: def dump_element
58: @elements.collect { |ele|
59: if ele.local_complextype
60: dump_classdef(ele.name, ele.local_complextype,
61: ele.elementform == 'qualified')
62: elsif ele.local_simpletype
63: dump_simpletypedef(ele.name, ele.local_simpletype)
64: else
65: nil
66: end
67: }.compact.join("\n")
68: end
# File lib/wsdl/soap/classDefCreator.rb, line 113
113: def dump_simpleclassdef(type_or_element)
114: qname = type_or_element.name
115: base = create_class_name(type_or_element.simplecontent.base)
116: c = XSD::CodeGen::ClassDef.new(create_class_name(qname), base)
117: c.comment = "#{qname}"
118: c.dump
119: end
# File lib/wsdl/soap/classDefCreator.rb, line 70
70: def dump_simpletype
71: @simpletypes.collect { |type|
72: dump_simpletypedef(type.name, type)
73: }.compact.join("\n")
74: end
# File lib/wsdl/soap/classDefCreator.rb, line 95
95: def dump_simpletypedef(qname, simpletype)
96: if !simpletype.restriction or simpletype.restriction.enumeration.empty?
97: return nil
98: end
99: c = XSD::CodeGen::ModuleDef.new(create_class_name(qname))
100: c.comment = "#{qname}"
101: const = {}
102: simpletype.restriction.enumeration.each do |value|
103: constname = safeconstname(value)
104: const[constname] ||= 0
105: if (const[constname] += 1) > 1
106: constname += "_#{const[constname]}"
107: end
108: c.def_const(constname, ndq(value))
109: end
110: c.dump
111: end
# File lib/wsdl/soap/classDefCreator.rb, line 194
194: def element_basetype(ele)
195: if klass = basetype_class(ele.type)
196: klass
197: elsif ele.local_simpletype
198: basetype_class(ele.local_simpletype.base)
199: else
200: nil
201: end
202: end
# File lib/wsdl/soap/classDefCreator.rb, line 260
260: def name_attribute(attribute)
261: return attribute.name if attribute.name
262: return attribute.ref if attribute.ref
263: raise RuntimeError.new("cannot define name of #{attribute}")
264: end