Module: Objectify::Xml::Dsl

Defined in:
lib/objectify_xml/dsl.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(target) ⇒ Object 



4
5
6
 
# File 'lib/objectify_xml/dsl.rb', line 4

def self.extended(target)
  target.init
end

Instance Method Details

#attribute(name, qualified_name = nil, collection = false) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/objectify_xml/dsl.rb', line 42

def attribute(name, qualified_name = nil, collection = false)
  name = name.to_s.underscore
  @qualified_attributes[qualified_name] = name if qualified_name
  @collections << (qualified_name || name).to_s if collection
  @attributes << name unless qualified_name
  module_eval %{
    def #{name}=(value)
      @attributes['#{name}'] = value
    end
    def #{name}
      @attributes['#{name}']#{ collection ? ' ||= []' : '' }
    end
  }
  name
end

#attribute_type(qualified_name) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/objectify_xml/dsl.rb', line 110

def attribute_type(qualified_name)
  type = @types[qualified_name]
  if type and not type.is_a? Class
    type_name = type.to_s
    begin
      type = type_name.constantize
    rescue
      # Try to search the current object's namespace explicitly
      sections = self.name.split(/::/)
      while sections.length > 1
        sections.pop
        begin
          sections.push(type_name)
          type = sections.join('::').constantize
          break
        rescue
          sections.pop
        end
      end
    end
    if type.nil?
      raise "Unable to instantiate the constant '#{ type_name }'."
    end
    @types[qualified_name] = type
  end
  type
end

#attributes(*names) ⇒ Object 



37
38
39
40
 
# File 'lib/objectify_xml/dsl.rb', line 37

def attributes(*names)
  names.each { |n| attribute n }
  @attributes + @qualified_attributes.keys
end

#collection?(qualified_name) ⇒ Boolean

Returns:

  • (Boolean) 


142
143
144
 
# File 'lib/objectify_xml/dsl.rb', line 142

def collection?(qualified_name)
  @collections.include?(qualified_name)
end

#default_namespace(url) ⇒ Object 



98
99
100
 
# File 'lib/objectify_xml/dsl.rb', line 98

def default_namespace(url)
  @namespaces[''] = url
end

#find_attribute(qualified_name, namespace, name) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/objectify_xml/dsl.rb', line 58

def find_attribute(qualified_name, namespace, name)
  if qname = @qualified_attributes[qualified_name]
    return qname
  end
  names = []
  plural = collection?(qualified_name)
  if plural
    if namespace
      names << "#{ namespace }_#{ name.pluralize }"
    end
    names << name.pluralize
  end
  if namespace
    names << "#{ namespace }_#{ name }"
  end
  names << name
  names.map { |n| n.underscore }.find do |n|
    @attributes.include? n.underscore
  end
end

#find_namespace(name = '') ⇒ Object 



106
107
108
 
# File 'lib/objectify_xml/dsl.rb', line 106

def find_namespace(name = '')
  @namespaces[name]
end

#flatten(qualified_name) ⇒ Object 



79
80
81
 
# File 'lib/objectify_xml/dsl.rb', line 79

def flatten(qualified_name)
  @flatten << qualified_name.to_s
end

#flatten?(qualified_name) ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/objectify_xml/dsl.rb', line 83

def flatten?(qualified_name)
  @flatten.include? qualified_name
end

#has_many(name, type, qualified_name) ⇒ Object 



32
33
34
35
 
# File 'lib/objectify_xml/dsl.rb', line 32

def has_many(name, type, qualified_name)
  set_type(qualified_name, type)
  attribute name, qualified_name, true
end

#has_one(name, type, qualified_name) ⇒ Object 



27
28
29
30
 
# File 'lib/objectify_xml/dsl.rb', line 27

def has_one(name, type, qualified_name)
  set_type(qualified_name, type)
  attribute name, qualified_name
end

#init ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/objectify_xml/dsl.rb', line 8

def init
  parent = ancestors[1]
  unless /^Objectify::(Xml|ElementParser|DocumentParser)$/ =~ parent.name
    @collections = parent.instance_variable_get('@collections').clone || []
    @attributes = parent.instance_variable_get('@attributes').clone || []
    @qualified_attributes = parent.instance_variable_get('@qualified_attributes').clone || {}
    @flatten = parent.instance_variable_get('@flatten').clone || []
    @namespaces = parent.instance_variable_get('@namespaces').clone || {}
    @types = parent.instance_variable_get('@types').clone || {}
  else
    @collections = []
    @attributes = []
    @qualified_attributes = {}
    @flatten = []
    @namespaces = {}
    @types = {}
  end
end

#metadata ⇒ Object 



146
147
148
149
150
151
152
153
 
# File 'lib/objectify_xml/dsl.rb', line 146

def metadata
  { :attributes => @attributes, 
    :qualified_attributes => @qualified_attributes, 
    :collections => @collections, 
    :flatten => @flatten, 
    :namespaces => @namespaces, 
    :types => @types }
end

#namespace(name = nil, url = nil) ⇒ Object 



102
103
104
 
# File 'lib/objectify_xml/dsl.rb', line 102

def namespace(name = nil, url = nil)
  @namespaces[name.to_s] = url
end

#namespace?(namespace) ⇒ Boolean

Returns:

  • (Boolean) 


87
88
89
 
# File 'lib/objectify_xml/dsl.rb', line 87

def namespace?(namespace)
  @namespaces.keys.include? namespace
end

#namespaces(*namespaces) ⇒ Object 



91
92
93
94
95
96
 
# File 'lib/objectify_xml/dsl.rb', line 91

def namespaces(*namespaces)
  namespaces.each do |ns|
    namespace ns
  end
  @namespaces
end

#set_type(qualified_name, type) ⇒ Object 



138
139
140
 
# File 'lib/objectify_xml/dsl.rb', line 138

def set_type(qualified_name, type)
  @types[qualified_name] = type
end