Module: CodeModels::Js

Defined in:
lib/codemodels/js/parser.rb,
lib/codemodels/js/version.rb,
lib/codemodels/js/language.rb,
lib/codemodels/js/metamodel.rb,
lib/codemodels/js/model_building.rb

Defined Under Namespace

Classes: BitwiseNotOperator, DefaultSwitchCase, DeleteOperator, ExpressionSwitchCase, GetObjectProperty, JsLanguage, JsNode, Loop, NotOperator, ObjectLiteral, ObjectProperty, Parser, PostfixDecrement, PostfixIncrement, PrefixDecrement, PrefixIncrement, SetObjectProperty, SimpleObjectProperty, TypeOfOperator, UnaryMinusOperator, UnaryPlusOperator

Constant Summary collapse

DefaultParser =

class Parser

Parser.new
ExpressionParser = 
Parser.new
VERSION = 
"0.1.1"
LANGUAGE = 
JsLanguage.new
JavaString = 
::Java::JavaClass.for_name("java.lang.String")
JavaBoolean = 
::Java::boolean.java_class
JavaInt = 
::Java::int.java_class
JavaDouble = 
::Java::double.java_class
JavaList = 
::Java::JavaClass.for_name("java.util.List")
JavaSortedSet = 
::Java::JavaClass.for_name("java.util.SortedSet")
JavaCollectionTypes = 
[JavaList,JavaSortedSet]
MappedAstClasses = 
{}
EXTENSION = 
'js'
@@additional_props = 
Hash.new {|h,k| h[k]={} }

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.verbose ⇒ Object

Returns the value of attribute verbose.



14
15
16
 
# File 'lib/codemodels/js/metamodel.rb', line 14

def verbose
  @verbose
end

Class Method Details

.add_feature(c, name, type, multiplicity) ⇒ Object 



119
120
121
122
123
124
125
126
127
 
# File 'lib/codemodels/js/metamodel.rb', line 119

def self.add_feature(c,name,type,multiplicity)
  return unless type # type nil means to ignore the feature
  method = if Js.get_att_type(type)
    multiplicity==:many ? :has_many_attr : :has_attr
  else
    multiplicity==:many ? :contains_many_uni : :contains_one_uni
  end
  c.send(method,name,type)
end

.add_many_ref_or_att(c, type_name, prop_name, ast_name) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/codemodels/js/metamodel.rb', line 89

def self.add_many_ref_or_att(c,type_name,prop_name,ast_name)
  rgen_class = get_metaclass_by_name(type_name)
  #puts "\trgen_class: #{rgen_class} from #{type_name} #{type_name.class}"
  if rgen_class
    c.class_eval do
      contains_many_uni prop_name, rgen_class
    end
  else
    att_type = get_att_type(type_name)
    if type_name
      c.class_eval { has_many_attr prop_name, att_type } 
    else
      raise "#{ast_name}) Property (many) #{prop_name} is else: #{type_name}"
    end
  end
end

.add_ref_or_att(c, type_name, prop_name, ast_name, multiplicity = :single) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/codemodels/js/metamodel.rb', line 61

def self.add_ref_or_att(c,type_name,prop_name,ast_name,multiplicity=:single)
  #puts "Adding #{type_name} to #{c}"
  case multiplicity
  when :single
    add_single_ref_or_att(c,type_name,prop_name,ast_name)
  when :many
    add_many_ref_or_att(c,type_name,prop_name,ast_name)
  else
    raise "wrong"
  end
end

.add_single_ref_or_att(c, type_name, prop_name, ast_name) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/codemodels/js/metamodel.rb', line 73

def self.add_single_ref_or_att(c,type_name,prop_name,ast_name)
  rgen_class = get_metaclass_by_name(type_name)
  if rgen_class
    c.class_eval do
      contains_one_uni prop_name, rgen_class
    end
  else
    att_type = get_att_type(type_name)
    if type_name
      c.class_eval { has_attr prop_name, att_type } 
    else
      raise "#{ast_name}) Property (many) #{prop_name} is else: #{type_name}"
    end
  end
end

.generate_model_per_file(src, dest, model_ext = "#{EXTENSION}.lm", max_nesting = 500, error_handler = nil) ⇒ Object 



24
25
26
27
28
29
 
# File 'lib/codemodels/js/model_building.rb', line 24

def self.generate_model_per_file(src,dest,model_ext="#{EXTENSION}.lm",max_nesting=500,error_handler=nil)
  CodeModels::ModelBuilding.generate_model_per_file(src,dest,max_nesting,error_handler) do |src|
    root = parse_file(src)
    CodeModels::Serialization.rgenobject_to_model(root)
  end
end

.generate_models_in_dir(src, dest, model_ext = "#{EXTENSION}.lm", max_nesting = 500, error_handler = nil) ⇒ Object 



17
18
19
20
21
22
 
# File 'lib/codemodels/js/model_building.rb', line 17

def self.generate_models_in_dir(src,dest,model_ext="#{EXTENSION}.lm",max_nesting=500,error_handler=nil)
  CodeModels::ModelBuilding.generate_models_in_dir(src,dest,EXTENSION,model_ext,max_nesting,error_handler) do |src|
    root = parse_file(src)
    CodeModels::Serialization.rgenobject_to_model(root)
  end
end

.get_att_type(type) ⇒ Object

Works with both Java and Ruby type



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/codemodels/js/metamodel.rb', line 44

def self.get_att_type(type)
  return type if [String,RGen::MetamodelBuilder::DataTypes::Boolean,Integer,Float].include?(type)
  return String if type.respond_to?(:enum?) and type.enum?   
  case type
  when JavaString
    String
  when JavaBoolean
    RGen::MetamodelBuilder::DataTypes::Boolean
  when JavaInt
    Integer
  when JavaDouble
    Float       
  else
    nil
  end
end

.get_corresponding_metaclass(node) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/codemodels/js/metamodel.rb', line 194

def self.get_corresponding_metaclass(node)
  node_class = node.class
  name = simple_java_class_name(node_class)
  if name=='InfixExpression'
    operator = AstNode::operatorToString(node.operator)
    name = INFIX_OPERATORS[operator]
    raise "Unknown operator for infix expression: #{operator}" unless name
  end
  if name=='UnaryExpression'
    operator = AstNode::operatorToString(node.operator)
    name = case operator
    when '++'
      node.prefix ? 'PrefixIncrement' : 'PostfixIncrement'
    when '--'
      node.prefix ? 'PrefixDecrement' : 'PostfixDecrement'
    when '~'
      'BitwiseNotOperator'
    when '!'
      'NotOperator'
    when '-'
      'UnaryMinusOperator'       
    when '+'
      'UnaryPlusOperator'  
    when 'typeof'             
      'TypeOfOperator'
    when 'delete'             
      'DeleteOperator'       
    else
      raise "Unknown unary operator: #{operator}"
    end
  end
  if name=='ObjectProperty'
    if node.getter?
      name='GetObjectProperty'
    elsif node.setter?
      name='SetObjectProperty'
    else
      name='SimpleObjectProperty'
    end
  end
  if name=='SwitchCase'
    if node.expression
      name='ExpressionSwitchCase'
    else
      name='DefaultSwitchCase'
    end
  end
  Js.const_get(name)
end

.get_metaclass_by_name(name) ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/codemodels/js/metamodel.rb', line 31

def self.get_metaclass_by_name(name)
  return JsNode if name=='JsNode'
  return JsNode if is_base_class?(name)
  k = MappedAstClasses.keys.find{|k| k.name==name}
  MappedAstClasses[k]
end

.getter?(java_method) ⇒ Boolean

Returns:

  • (Boolean) 


190
191
192
 
# File 'lib/codemodels/js/metamodel.rb', line 190

def self.getter?(java_method)
  (java_method.name.start_with?('get')||java_method.name.start_with?('is')) and java_method.argument_types.count==0    
end

.handle_models_in_dir(src, error_handler = nil, model_handler) ⇒ Object 



10
11
12
13
14
15
 
# File 'lib/codemodels/js/model_building.rb', line 10

def self.handle_models_in_dir(src,error_handler=nil,model_handler)
  CodeModels::ModelBuilding.handle_models_in_dir(src,EXTENSION,error_handler,model_handler) do |src|
    root = parse_file(src)
    CodeModels::Serialization.rgenobject_to_model(root)
  end
end

.is_base_class?(name) ⇒ Boolean

Returns:

  • (Boolean) 


38
39
40
41
 
# File 'lib/codemodels/js/metamodel.rb', line 38

def self.is_base_class?(name)
  # Object is here because of Symbol, which does not extenf Node
  ['org.mozilla.javascript.Node','org.mozilla.javascript.ast.AstNode','java.lang.Object'].include? name
end

.metasuperclass(java_super_class) ⇒ Object 



110
111
112
113
114
115
116
117
 
# File 'lib/codemodels/js/metamodel.rb', line 110

def self.metasuperclass(java_super_class)
  if is_base_class?(java_super_class.name)       
    JsNode
  else
    raise "Super class #{java_super_class.name} not found, it should be wrapped before the classes extending it!" unless MappedAstClasses[java_super_class]
    MappedAstClasses[java_super_class]
  end
end

.parse_code(code) ⇒ Object 



219
220
221
 
# File 'lib/codemodels/js/parser.rb', line 219

def self.parse_code(code)
  DefaultParser.parse_code(code)
end

.parse_file(path, encoding = nil) ⇒ Object 



223
224
225
 
# File 'lib/codemodels/js/parser.rb', line 223

def self.parse_file(path,encoding=nil)
  DefaultParser.parse_file(path,encoding)
end

.rhino_node_class(name) ⇒ Object 



106
107
108
 
# File 'lib/codemodels/js/metamodel.rb', line 106

def self.rhino_node_class(name)
  java_class = ::Java::JavaClass.for_name("org.mozilla.javascript.ast.#{name}")
end

.wrap(ast_names) ⇒ Object 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/codemodels/js/metamodel.rb', line 129

def self.wrap(ast_names)    
  # first create all the classes
  ast_names.each do |ast_name|
    ast_java_class   = rhino_node_class(ast_name)
    meta_super_class = metasuperclass(ast_java_class.superclass)      
    meta_class       = Class.new(meta_super_class)
    
    raise "Already mapped! #{ast_name}" if MappedAstClasses[ast_java_class]
    MappedAstClasses[ast_java_class] = meta_class
    
    Js.const_set ast_java_class.simple_name, meta_class
  end

  # then add all the properties and attributes
  ast_names.each do |ast_name|
    java_class = rhino_node_class(ast_name)
    ast_class  = java_class.ruby_class
    c = MappedAstClasses[java_class]
      
    to_ignore = %w( symbolTable compilerData comments liveLocals regexpString
      regexpFlags indexForNameNode paramAndVarCount paramAndVarNames
      paramAndVarConst jumpStatement finally loop default continue
      containingTable definingScope parentScope top quoteCharacter
      sourceName inStrictMode encodedSourceStart encodedSourceEnd
      baseLineno endLineno functionCount regexpCount paramCount nextTempName
      functions symbols childScopes encodedSource statement var const let
      destructuring localName scope operatorPosition
     )

    c.class_eval do
      ast_class.java_class.declared_instance_methods.select { |m| Js.getter?(m) }.each do |m|
        prop_name = CodeModels::Js.property_name(m)
        unless to_ignore.include?(prop_name)
          if PROP_ADAPTERS[ast_class.simple_name.to_sym][prop_name.to_sym] 
            #puts "Adapting #{ast_class.simple_name} #{prop_name}"          
            adapter = PROP_ADAPTERS[ast_class.simple_name.to_sym][prop_name.to_sym]
            #puts "Type of adapter = #{adapter[:type]==nil}"
            Js.add_feature(c,prop_name,adapter[:type],adapter[:multiplicity])
          elsif Js.get_att_type(m.return_type)
            # the type is simple (-> attribute)
            has_attr prop_name, Js.get_att_type(m.return_type)
          elsif MappedAstClasses.has_key?(m.return_type)
            # the type is complex (-> reference)
            contains_one_uni prop_name, MappedAstClasses[m.return_type]
          elsif JavaCollectionTypes.include?(m.return_type)              
            type_name = CodeModels::Js.get_generic_param_name(m.to_generic_string)
            CodeModels::Js.add_many_ref_or_att(c,type_name,prop_name,ast_name)
          elsif m.return_type.array?
            CodeModels::Js.add_many_ref_or_att(c,m.return_type.component_type.name,prop_name,ast_name)
          elsif Js.is_base_class?(m.return_type.name)
            #puts "#{ast_class.simple_name} #{prop_name} is base type"    
            contains_one_uni prop_name, JsNode
          else
            raise "#{ast_name}) Property (single) '#{prop_name}' is else: #{m.return_type}"
          end
        end
      end
    end
  end
end