codemodels 0.2.2-java → 0.2.3-java

data/lib/codemodels/parsing.rb

@@ -2,6 +2,14 @@ require 'codemodels/monkey_patching'
 
 module CodeModels
 
+class Parser
+
+	def parse_file(path)
+		parse_code(IO.read(path))
+	end
+
+end
+
 class ParsingError < Exception
  	attr_reader :node
  	attr_reader :line
@@ -26,159 +34,4 @@ class UnknownNodeType < ParsingError
 
 end
 
-module ParserWrapper
-
-@@verbose = false
-
-JavaCollection = ::Java::JavaClass.for_name("java.util.Collection")
-	
-def adapter(model_class,ref)
-	if adapter_specific_class(model_class,ref)
-		adapter_specific_class(model_class,ref)
-	else
-		if model_class.superclass!=Object
-			adapter(model_class.superclass,ref) 
-		else
-			nil
-		end
-	end
-end
-
-def reference_to_method(model_class,ref)
-	s = ref.name
-	#s = 'value' if s=='body'
-	adapted = adapter(model_class,ref)
-	s = adapted if adapted		
-	s.to_sym
-end
-
-def attribute_to_method(model_class,att)
-	s = att.name
-	adapted = adapter(model_class,att)
-	s = adapted if adapted		
-	s.to_sym
-end
-
-def assign_ref_to_model(model,ref,value)
-	return unless value==nil # we do not need to assign a nil...
-	if ref.many
-		adder_method = :"add#{ref.name.capitalize}"
-		value.each {|el| model.send(adder_method,node_to_model(el))}
-	else
-		setter_method = :"#{ref.name}="
-		raise "Trying to assign an array to a single property. Class #{model.class}, property #{ref.name}" if value.is_a?(::Array)
-		model.send(setter_method,node_to_model(value))
-	end
-rescue Object => e
-	puts "Problem while assigning ref #{ref.name} (many? #{ref.many}) to #{model.class}. Value: #{value.class}"
-	puts "\t<<#{e}>>"
-	raise e
-end
-
-def assign_att_to_model(model,att,value)
-	if att.many
-		adder_method = :"add#{att.name.capitalize}"
-		value.each {|el| model.send(adder_method,el)}
-	else
-		setter_method = :"#{att.name}="
-		raise "Trying to assign an array to a single property. Class #{model.class}, property #{att.name}" if value.is_a?(::Array)
-		model.send(setter_method,value)
-	end
-end
-
-def populate_attr(node,att,model)	
-	value = get_feature_value(node,att)
-	model.send(:"#{att.name}=",value) if value!=nil
-rescue Object => e
-	puts "Problem while populating attribute #{att.name} of #{model} from #{node}. Value: #{value}"
-	raise e
-end
-
-def populate_ref(node,ref,model)
-	log("populate ref #{ref.name}, node: #{node.class}, model: #{model.class}")
-	value = get_feature_value(node,ref)
-	log("\tvalue=#{value.class}")
-	if value!=nil
-		if value==node
-			puts "avoiding loop... #{ref.name}, class #{node.class}" 
-			return
-		end
-		if JavaCollection.assignable_from?(value.java_class)
-			log("\tvalue is a collection")
-			capitalized_name = ref.name.proper_capitalize				
-			value.each do |el|
-				unless el.respond_to?(:parent)
-					class << el
-						attr_accessor :parent						
-					end
-				end
-				el.parent = node
-				model.send(:"add#{capitalized_name}",node_to_model(el))
-			end
-		else
-			log("\tvalue is not a collection")
-			unless value.respond_to?(:parent)
-				value.class.__persistent__ = true
-				class << value
-					attr_accessor :parent
-				end
-			end
-			value.parent = node
-			model.send(:"#{ref.name}=",node_to_model(value))
-		end
-	end
-end
-
-def log(msg)
-	puts msg if @@verbose
-end
-
-def node_to_model(node)
-	log("node_to_model #{node.class}")
-	metaclass = get_corresponding_metaclass(node)
-	instance = metaclass.new
-	metaclass.ecore.eAllAttributes.each do |attr|
-		populate_attr(node,attr,instance)
-	end
-	metaclass.ecore.eAllReferences.each do |ref|
-		populate_ref(node,ref,instance)
-	end
-	instance
-end
-
-def transform_enum_values(value)
-	if value.respond_to?(:java_class) && value.java_class.enum?
-		value.name
-	else
-		value
-	end
-end
-
-def get_feature_value_through_getter(node,feat_name)
-	capitalized_name = feat_name.proper_capitalize
-	methods = [:"get#{capitalized_name}",:"is#{capitalized_name}"]
-
-	methods.each do |m|
-		if node.respond_to?(m)
-			begin
-				return transform_enum_values(node.send(m))
-			rescue Object => e
-				raise "Problem invoking #{m} on #{node.class}: #{e}"
-			end
-		end
-	end
-	raise "how should I get this... #{feat_name} on #{node.class}. It does not respond to #{methods}"
-end
-
-def get_feature_value(node,feat)
-	adapter = adapter(node.class,feat)		
-	if adapter
-		adapter[:adapter].call(node)
-	else
-		get_feature_value_through_getter(node,feat.name)
-	end
-end
-
-end
-
 end

data/lib/codemodels/rgen_ext.rb

@@ -12,17 +12,12 @@ class RGen::MetamodelBuilder::MMBase
 				values.each do |k,v|
 					attribute = self.ecore.eAllAttributes.find {|x| x.name==k.to_s}
 					reference = self.ecore.eAllReferences.find {|x| x.name==k.to_s}
-					raise EMF::UnexistingFeature.new(k.to_s) unless (attribute or reference)
+					raise "UnexistingFeature #{k}" unless (attribute or reference)
 					setter = (k.to_s+'=').to_sym
 					instance.send setter, v
 				end
 			else
-				has_dynamic = false
-				self.ecore.eAllAttributes.each {|a| has_dynamic|=a.name=='dynamic'}
-				d = 0
-				d = 1 if has_dynamic
-
-				raise EMF::SingleAttributeRequired.new(self.ecore.name,self.ecore.eAllAttributes) if self.ecore.eAllAttributes.count!=1+d
+				raise "SingleAttributeRequired" if self.ecore.eAllAttributes.count!=1
 				attribute = self.ecore.eAllAttributes[0]
 				set_attr(instance,attribute,values)
 			end
@@ -45,12 +40,9 @@ class RGen::MetamodelBuilder::MMBase
 			return false unless self.class==other.class
 			self.class.ecore.eAllAttributes.each do |attrib|
 				raise "Attrib <nil> for class #{self.class.ecore.name}" unless attrib
-				if attrib.name != 'dynamic' # I have to understand this...
-					self_value  = self.get(attrib)
-					other_value = other.get(attrib)
-					#puts "returning false on #{attrib.name}" unless self_value.eql?(other_value)
-					return false unless self_value == other_value
-				end
+				self_value  = self.get(attrib)
+				other_value = other.get(attrib)
+				return false unless self_value == other_value
 			end
 			true
 		end
@@ -95,92 +87,47 @@ class RGen::MetamodelBuilder::MMBase
 			send getter
 		end
 
-		def all_children
-			arr = []
+		def features_by_name(name)
+			features = []
 			ecore = self.class.ecore
-			ecore.eAllReferences.select {|r| r.containment}.each do |ref|
-				res = self.send(ref.name.to_sym)
-				if ref.many
-					d = arr.count
-					res.each do |el|
-						arr << el unless res==nil
-					end
-				elsif res!=nil
-					d = arr.count
-					arr << res
-				end
-			end
-			arr
-		end
-
-		def all_children_deep
-			arr = []
-			all_children.each do |c|
-				arr << c
-				c.all_children_deep.each do |cc|
-					arr << cc
-				end
+			ecore.eAllAttributes.select {|a| a.name==name}.each do |a|
+				features << a
 			end			
-			arr
-		end
-
-		def traverse(&op)
-			op.call(self)
-			all_children_deep.each do |c|
-				op.call(c)
+			ecore.eAllReferences.select {|r| r.name==name}.each do |r|
+				features << r
 			end
+			features
 		end
 
-		def collect_values_with_count
-			values = Hash.new {|h,k| h[k]=0}
-			self.class.ecore.eAllAttributes.each do |a|
-				v = self.send(:"#{a.name}")
-				if v!=nil
-					if a.many
-						v.each {|el| values[el]+=1}
-					else
-						values[v]+=1
-					end
-				end
-			end
-			values			
-		end
-
-		def collect_values_with_count_subtree
-			values = collect_values_with_count
-			all_children_deep.each do |c|
-				c.collect_values_with_count.each do |k,v|
-					values[k]+=v
-				end
-			end
-			values
-		end		
+	end
 
-		def all_children_of_type(type)
-			all_children.select {|c| c and c.is_a?(type)}
+	module FixingCollidingFeatureAddOn
+		def has_attr(role, target_class=nil, raw_props={}, &block)
+			raise "Role already used #{role}" if self.ecore.eAllAttributes.find {|a| a.name==role.to_s}
+			raise "Role already used #{role}" if self.ecore.eAllReferences.find {|r| r.name==role.to_s}
+			super(role,target_class,raw_props,block)
 		end
-
-		def all_children_deep_of_type(type)
-			all_children_deep.select {|c| c and c.is_a?(type)}
+		def has_many_attr(role, target_class=nil, raw_props={}, &block)
+			raise "Role already used #{role}" if self.ecore.eAllAttributes.find {|a| a.name==role.to_s}
+			raise "Role already used #{role}" if self.ecore.eAllReferences.find {|r| r.name==role.to_s}
+			super(role,target_class,raw_props,block)
 		end
-
-		def only_child_of_type(type)
-			selected = all_children_of_type(type)
-			raise "Exactly one child of type #{type} expected, #{selected.count} found on #{self}" unless selected.count==1
-			selected[0]
+		def contains_many_uni(role, target_class=nil, raw_props={}, &block)
+			raise "Role already used #{role}" if self.ecore.eAllAttributes.find {|a| a.name==role.to_s}
+			raise "Role already used #{role}" if self.ecore.eAllReferences.find {|r| r.name==role.to_s}
+			super(role,target_class,raw_props,block)
 		end
-
-		def only_child_deep_of_type(type)
-			selected = all_children_deep_of_type(type)
-			raise "Exactly one child of type #{type} expected, #{selected.count} found on #{self}" unless selected.count==1
-			selected[0]
+		def contains_one_uni(role, target_class=nil, raw_props={}, &block) 
+			raise "Role already used #{role}" if self.ecore.eAllAttributes.find {|a| a.name==role.to_s}
+			raise "Role already used #{role}" if self.ecore.eAllReferences.find {|r| r.name==role.to_s}
+			super(role,target_class,raw_props,block)
 		end
-
 	end
 
 	class << self
 		include ClassAddOn
 	end
 
+	include FixingCollidingFeatureAddOn
 	include SingletonAddOn
 end

data/lib/codemodels/serialization.rb

@@ -10,38 +10,16 @@ module Serialization
 
 module SerializationFunctionalities
 
-	# It could be a simple hash with a block passed to the
-	# constructor...
-	class SerializationMemory
-
-		def initialize
-			@next_id = 1
-			@id_map = {}
-		end
-
-		def id(rgen_object)
-			unless @id_map[rgen_object]
-				@id_map[rgen_object] = @next_id
-				@next_id += 1
-			end
-			@id_map[rgen_object]
-		end
-
-	end
+	def to_json(params={})
+		serialization_memory = params.fetch(:memory,SerializationMemory.new)
+		adapters			 = params.fetch(:adapters,{})
+		with_source_info	 = params.fetch(:source_info,true)
 
-	def to_json(serialization_memory=SerializationMemory.new,adapters={},with_source_info=true)
 		e_object = self
-		map = { 'type' => qname, 'id' => serialization_memory.id(e_object) }
+		map = { 'type' => type, 'id' => serialization_memory.id(e_object) }
 		if with_source_info
-			if self.respond_to?(:source) && self.source
-				source_map = {}
-				if self.source.begin_pos
-					source_map['begin_pos'] = {'line'=> self.source.begin_pos.line, 'column'=>self.source.begin_pos.column}
-				end				
-				if self.source.end_pos
-					source_map['end_pos'] = {'line'=> self.source.end_pos.line, 'column'=>self.source.end_pos.column}
-				end								
-				map['source'] = source_map
+			if self.respond_to?(:source) && self.source								
+				map['source'] = source_info_to_json(self.source)
 			end
 		end
 		e_class = e_object.class.ecore
@@ -51,21 +29,32 @@ module SerializationFunctionalities
 		e_class.eAllReferences.each do |r|
 			id = jsonize_ref_value(map,r,adapters,serialization_memory)
 		end
-		if adapters.has_key? qname
-			adapters[qname].adapt(self,map)
+		if adapters.has_key? type
+			adapters[type].adapt(self,map)
 		end
 		map
 	end
 
 	private
 
-	def qname
+	def source_info_to_json(source_info)
+		source_map = {}
+		if self.source.begin_pos
+			source_map['begin_pos'] = {'line'=> self.source.begin_pos.line, 'column'=>self.source.begin_pos.column}
+		end				
+		if self.source.end_pos
+			source_map['end_pos'] = {'line'=> self.source.end_pos.line, 'column'=>self.source.end_pos.column}
+		end			
+		source_map	
+	end
+
+	def type
 		self.class.to_s
 	end
 
 	def jsonize_attr_value(map,e_attr)
 		value = self.send(e_attr.name.to_sym)
-		if e_attr.upperBound==1
+		unless e_attr.many
 			map["attr_#{e_attr.name}"] = value
 		else
 			l = []
@@ -82,7 +71,7 @@ module SerializationFunctionalities
 		propname = "relcont_#{e_ref.name}" if e_ref.containment
 		propname = "relnoncont_#{e_ref.name}" if not e_ref.containment
 
-		if e_ref.upperBound==1		
+		unless e_ref.many		
 			map[propname] = jsonize_ref_single_el(value,e_ref.containment,adapters,serialization_memory)
 		else
 			l = []
@@ -95,23 +84,38 @@ module SerializationFunctionalities
 
 	def jsonize_ref_single_el(single_value,containment,adapters,serialization_memory)
 		if containment
-			single_value.to_json(serialization_memory,adapters)
+			single_value.to_json(memory:serialization_memory,adapters:adapters)
 		else
 			serialization_memory.id(single_value)
 		end
 	end
 
-end
+	# It could be a simple hash with a block passed to the
+	# constructor...
+	class SerializationMemory
+
+		def initialize
+			@next_id = 1
+			@id_map = {}
+		end
+
+		def id(rgen_object)
+			unless @id_map[rgen_object]
+				@id_map[rgen_object] = @next_id
+				@next_id += 1
+			end
+			@id_map[rgen_object]
+		end
+
+	end
 
-class ::RGen::MetamodelBuilder::MMBase
-	include SerializationFunctionalities
 end
 
 def self.load_file(path,max_nesting=500)
 	JSON.parse(File.read(path),{max_nesting: max_nesting})
 end
 
-def self.save_model(model,model_path, max_nesting=500)
+def self.save_model(model,model_path,max_nesting=500)
 	dir = File.dirname(model_path)
 	FileUtils.mkdir_p(dir) 
 
@@ -125,10 +129,10 @@ def self.rgenobject_to_model(root,adapters={})
 	external_elements = []
 
 	sm = SerializationFunctionalities::SerializationMemory.new
-	model['root'] = root.to_json(sm,adapters)
+	model['root'] = root.to_json(memory:sm,adapters:adapters)
 	model['external_elements'] = []
 	external_elements.each do |ee|
-		model['external_elements'] << ee.to_json(sm,adapters)
+		model['external_elements'] << ee.to_json(memory:sm,adapters:adapters)
 	end
 	model
 end
@@ -139,4 +143,5 @@ def self.save_as_model(root,model_path)
 end
 
 end # module
+
 end # module

data/lib/codemodels/source_info.rb

@@ -0,0 +1,192 @@
+require 'rgen/metamodel_builder'
+require 'codemodels/language'
+
+module CodeModels
+
+class AbstractArtifact
+
+	def point_to_absolute(point)
+		offset = absolute_start
+		p = SourcePoint.new
+		p.line   = point.line  + offset.line - 1
+		p.column = point.column
+		p.column  += offset.column-1 if point.line==1
+		p
+	end
+
+	def position_to_absolute(position)
+		pos = SourcePosition.new
+		pos.begin_point = point_to_absolute(position.begin_point)
+		pos.end_point = point_to_absolute(position.end_point)
+		pos
+	end
+
+end
+
+class EmbeddedArtifact < AbstractArtifact
+	attr_accessor :host_artifact
+	attr_accessor :position_in_host
+
+	def absolute_start
+		p = host_artifact.absolute_start
+		p.line   += position_in_host.begin_point.line-1
+		if position_in_host.begin_point.line==1			
+			# if I am on the first line of my "host", its column
+			# matters because there are not newlines to reset the column
+			# counter
+			p.column += position_in_host.begin_point.column-1 
+		else
+			p.column = position_in_host.begin_point.column
+		end
+		p
+	end
+
+end
+
+class FileArtifact < AbstractArtifact
+	attr_accessor :filename
+
+	def absolute_start
+		sp = SourcePoint.new
+		sp.line   = 1
+		sp.column = 1
+		sp
+	end
+end
+
+class SourcePoint
+	attr_accessor :line, :column
+
+	def initialize(line=nil,column=nil)
+		@line   = line
+		@column = column
+	end
+
+	def eql?(other)
+		other.line==line && other.column==column
+	end
+
+	def ==(other)
+		self.eql?(other)
+	end
+end
+
+class SourcePosition
+	attr_accessor :begin_point, :end_point
+
+	def initialize(begin_point=nil,end_point=nil)
+		@begin_point = begin_point
+		@end_point = end_point
+	end
+
+	def begin_line=(line)
+		@begin_point=SourcePoint.new unless @begin_point
+		@begin_point.line = line
+	end
+
+	def begin_column=(column)
+		@begin_point=SourcePoint.new unless @begin_point
+		@begin_point.column = column
+	end
+
+	def eql?(other)
+		other.begin_point==begin_point && other.end_point==end_point
+	end
+
+	def ==(other)
+		self.eql?(other)
+	end
+end
+
+class SourceInfo
+	attr_accessor :artifact
+	attr_accessor :position
+
+	def to_code
+		raise "Unimplemented"
+	end
+
+	def begin_point=(data)
+		point = data_to_point(data)
+		@position = SourcePosition.new unless @position
+		@position.begin_point = point
+	end
+
+	def end_point=(data)
+		point = data_to_point(data)
+		@position = SourcePosition.new unless @position
+		@position.end_point = point		
+	end
+
+	def begin_line
+		position.begin_point.line
+	end
+
+	def end_line
+		position.end_point.line
+	end	
+
+	private
+
+	def data_to_point(data)
+		if data.is_a? Hash
+			point = SourcePoint.new
+			point.line   = data[:line]
+			point.column = data[:column]
+		elsif data.is_a? SourcePoint
+			point = data
+		else
+			raise "Expected Hash or SourcePoint"
+		end
+		point
+	end
+
+end	
+
+# This extension give all the information about the source
+# from which the node was derived
+module SourceInfoExtensions
+	attr_accessor :language
+	attr_accessor :source	
+
+	def set_start_point(data)
+		@source = SourceInfo.new unless @source
+		@source.set_start_point(data)
+	end
+
+	def set_end_point(data)
+		@source = SourceInfo.new unless @source
+		@source.set_end_point(data)		
+	end
+end
+
+# Inside an host language snippet of other languages can be hosted
+# For example Java code could contain in a string literal a sql statement
+# or an Html file can contain CSS or Javascript code.
+# In those cases an AST is inserted inside the AST of the host language.
+module ForeignAstExtensions
+
+	attr_accessor :foreign_container
+
+	def addForeign_asts(foreign_ast)
+		foreign_asts << foreign_ast
+		foreign_ast.foreign_container = self
+	end
+
+	def foreign_asts
+		@foreign_asts=[] unless @foreign_asts
+		@foreign_asts
+	end
+end
+
+module HostPositionExtensions
+
+	def absolute_position
+		artifact = source.artifact
+		artifact.absolute_position(source.position)
+	end
+
+end
+
+
+end

data/lib/codemodels/version.rb

@@ -1,3 +1,3 @@
 module CodeModels
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/codemodels.rb

@@ -1,5 +1,3 @@
 curr_dir = File.dirname(__FILE__)
 
-Dir[curr_dir+"/codemodels/*.rb"].each do |rb|
-	require rb
-end
+Dir["#{curr_dir}/codemodels/*.rb"].each { |rb| require rb }