Class WSDL::SOAP::ClassDefCreator
In: lib/wsdl/soap/classDefCreator.rb
Parent: Object

Methods

Included Modules

ClassDefCreatorSupport

Constants

DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item')

Public Class methods

[Source]

    # 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

Public Instance methods

[Source]

    # 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

Private Instance methods

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

    # 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

[Source]

    # 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

[Source]

     # 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

[Source]

    # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # File lib/wsdl/soap/classDefCreator.rb, line 254
254:   def name_element(element)
255:     return element.name if element.name 
256:     return element.ref if element.ref
257:     raise RuntimeError.new("cannot define name of #{element}")
258:   end

[Validate]