Class: RGen::ECore::ECoreToJson

Inherits:
Object
  • Object
show all
Defined in:
lib/rgen/ecore/ecore_to_json.rb

Overview

ECoreToJson can turn ECore models into their JSON metamodel representations

Instance Method Summary collapse

Constructor Details

#initialize ⇒ ECoreToJson

Returns a new instance of ECoreToJson.



12
13
14
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 12

def initialize

end

Instance Method Details

#eannotation(e) ⇒ Object 



117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 117

def eannotation(e)
  merge(emodelelement(e), {
    :_class_ref => 'RGen.ECore.EAnnotation',
    :source => e.source,
    :details => e.details.map do |d|
      merge({}, {
          :_class_ref => 'RGen.ECore.EStringToStringMapEntry',
          :key => d.key,
          :value => d.value
      })
    end
  })
end

#eattribute(attr) ⇒ Object 



154
155
156
157
158
159
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 154

def eattribute(attr)
  merge(estructuralfeature(attr), {
    :_class_ref => 'RGen.ECore.EAttribute',
    :iD => attr.iD
  })
end

#eclass(_class) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 81

def eclass(_class)
  merge(eclassifier(_class), {
    :_class_ref => 'RGen.ECore.EClass',
    :abstract => _class.abstract,
    :interface => _class.interface,
    :eStructuralFeatures => _class.eStructuralFeatures.map do |sf|
      if sf.is_a?(RGen::ECore::EReference)
        ereference(sf)
      else
        eattribute(sf)
      end
    end,
    :eSuperTypes => _class.eSuperTypes.map { |st| {:_ref => ref_id(st)} }
  })
end

#eclassifier(classifier) ⇒ Object 



75
76
77
78
79
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 75

def eclassifier(classifier)
  enamedelement(classifier).merge({
    # omit :instanceClassName => classifier.instanceClassName
  })
end

#ecore_datatypes ⇒ Object 



32
33
34
35
36
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 32

def ecore_datatypes
  [RGen::ECore::EString, RGen::ECore::EInt, RGen::ECore::ELong, RGen::ECore::EBoolean, RGen::ECore::EFloat,
   RGen::ECore::ERubyObject, RGen::ECore::EJavaObject, RGen::ECore::ERubyClass, RGen::ECore::EJavaClass]
      .map {|dt| edatatype(dt)}
end

#edatatype(_datatype) ⇒ Object 



97
98
99
100
101
102
103
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 97

def edatatype(_datatype)
  merge(eclassifier(_datatype), {
    :_class_ref => 'RGen.ECore.EDataType',
    :serializable => _datatype.serializable,
    :instanceClassName => _datatype.instanceClassName
  })
end

#eenum(enum) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 105

def eenum(enum)
  merge(edatatype(enum), {
    :_class_ref => 'RGen.ECore.EEnum',
    :eLiterals => enum.eLiterals.map do |l|
      merge(enamedelement(l), {
        :_class_ref => 'RGen.ECore.EEnumLiteral',
        :value => l.value,
      })
    end      
  })
end

#emodelelement(me) ⇒ Object 



46
47
48
49
50
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 46

def emodelelement(me)
  {
    :eAnnotations => me.eAnnotations.map { |e| eannotation(e) }
  }
end

#enamedelement(ne) ⇒ Object 



53
54
55
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 53

def enamedelement(ne)
  merge(emodelelement(ne), {:name => ne.name})
end

#epackage(package) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 57

def epackage(package)
  merge(enamedelement(package), {
    :_class_ref => 'RGen.ECore.EPackage',
    :eClassifiers => package.eClassifiers.map do |classifier|
      if classifier.is_a?(RGen::ECore::EClass)
        eclass(classifier)
      elsif classifier.is_a?(RGen::ECore::EEnum)
        eenum(classifier)
      else
        edatatype(classifier)
      end
    end,
    :eSubpackages => package.eSubpackages.map { |sp| epackage(sp) },
    :nsURI => package.nsURI,
    :nsPrefix => package.nsPrefix
  })
end

#epackage_to_json(package) ⇒ Object 



28
29
30
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 28

def epackage_to_json(package)
  epackage(package)
end

#epackage_to_json_pretty_string(package, append = []) ⇒ Object 



38
39
40
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 38

def epackage_to_json_pretty_string(package, append = [])
  JSON.pretty_generate([epackage_to_json(package)] + append)
end

#epackage_to_json_string(package, append = []) ⇒ Object 



42
43
44
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 42

def epackage_to_json_string(package, append = [])
  JSON.generate([epackage_to_json(package)] + append)
end

#ereference(ref) ⇒ Object 



161
162
163
164
165
166
167
168
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 161

def ereference(ref)
  merge(estructuralfeature(ref), {
    :_class_ref => 'RGen.ECore.EReference',
    :containment => ref.containment,
    :resolveProxies => ref.resolveProxies,
    :eOpposite => ref.eOpposite ? {:_ref => "#{ref_id(ref.eOpposite.eContainer)}.#{ref.eOpposite.name}"} : nil
  })
end

#estructuralfeature(sf) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 143

def estructuralfeature(sf)
  merge(etypedelement(sf), {
    :changeable => sf.changeable,
    :volatile => sf.volatile,
    :transient => sf.transient,
    :defaultValueLiteral => sf.defaultValueLiteral,
    :unsettable => sf.unsettable,
    :derived => sf.derived,
  })
end

#etypedelement(te) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 131

def etypedelement(te)
  merge(enamedelement(te), {
    :ordered => te.ordered,
    :unique => te.unique,
    :lowerBound => te.lowerBound,
    :upperBound => te.upperBound,
    :many => te.many,
    :required => te.required,
    :eType => {:_ref => te.eType ? ref_id(te.eType) : nil}
  })
end

#merge(hash, values) ⇒ Object 



180
181
182
183
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 180

def merge(hash, values)
  values.each { |k, v| hash[k] = v unless v.nil? }
  hash
end

#ref_id(obj) ⇒ Object 



170
171
172
173
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 170

def ref_id(obj)
  res = ref_parts(obj)
  res.join('.')
end

#ref_parts(obj) ⇒ Object 



175
176
177
178
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 175

def ref_parts(obj)
  return [obj.name] unless obj.andand.eContainer
  ref_parts(obj.eContainer) << obj.name 
end

#root_elements_to_json_string(root_elements) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/rgen/ecore/ecore_to_json.rb', line 16

def root_elements_to_json_string(root_elements)
  JSON.pretty_generate(root_elements.map do |el|
    if el.is_a?(RGen::ECore::EPackage)
      epackage(el)
    elsif el.is_a?(RGen::ECore::EClass)
      eclass(el)
    else
      raise "Not implemented for #{el}"
    end
  end)
end