EFL 1.0

data/README.txt

@@ -0,0 +1,36 @@
+Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose 
+Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.
+
+This is EFL - A Ruby implementation of the Exemplar Flexibilization Language.
+
+EFL is distributed under the terms of the GNU Lesser General Public License
+(LGPL).
+
+EFL is free software: you can redistribute it and/or modify it under the terms
+of the GNU Lesser General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+
+EFL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es).
+Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y 
+Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16.
+28040 Madrid.
+
+===============================================================================
+EFL 1.0 - A Ruby implementation of the Exemplar Flexibilization Language
+===============================================================================
+
+With EFL you can write program generators by analogy (see the Generator class).
+EFL is integrated in the Exemplar Driven Development (EDD) process.
+EDD has been developed by Ruben Heradio to build Software Product Lines (SPLs)
+in a reactive and an extractive way.
+The theoretical basis of EDD and EFL, and a wide variety of examples can be
+found in:
+http://www.issi.uned.es/miembros/pagpersonales/ruben_heradio/rheradio_english.html

data/lib/EFL.rb

@@ -0,0 +1,494 @@
+# :title: EFL 1.0 - A Ruby implementation of the Exemplar Flexibilization Language
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+#
+# <b>With EFL you can write program generators by analogy (see the Generator class).</b>
+# <b>EFL is integrated in the Exemplar Driven Development (EDD) process.</b>
+# <b>EDD has been developed by Ruben Heradio to build Software Product Lines (SPLs) in a reactive and an extractive way.</b>
+# <b>The theoretical basis of EDD and EFL, and a wide variety of examples can be found in http://www.issi.uned.es/miembros/pagpersonales/ruben_heradio/rheradio_english.html</b>
+
+require 'EFL_substitution'
+require 'EFL_production'
+require 'EFL_regexp'
+require 'EFL_hash'
+require 'EFL_array'
+require 'EFL_syntactic_sugar'
+require 'EFL_errors'
+require 'EFL_regexp_generator'
+
+#:include: EFL_syntactic_sugar.rb
+
+# * Generators are specified using substititions (with the <em>sub</em> and <em>gsub</em> methods), productions (with the <em>prod</em> method) and generations (with the <em>gen</em> method).
+# * Generators can be combined in a sequential orden or mixed using the add (with the + and <em>add</em> methods) and the superposition (with the << and <em>sup!</em> methods).
+
+class Generator 
+	
+	attr_accessor :sub_hash, :prod_hash #:nodoc:
+	
+  
+	# Specifies the change of the first occurrence of the pattern expressed by 
+	# the <tt>reg_exp</tt> regular expression to the <tt>text</tt> string. Optionally, 
+	# a substitution can be named using the <tt>name</tt> string.
+	# To build complex substitution patterns, the regular expressions can be combined
+	# using the zoom operator (Regexp#>).
+	
+	def sub(reg_exp, text, name = nil)
+		sub_aux(reg_exp, text, name, 'local')
+	end #sub
+	
+	
+	# Specifies a kind of substitution that deletes the first occurrence of the 
+	# pattern expressed by the <tt>reg_exp</tt> regular expression. Optionally, 
+	# this substitution can be named using the <tt>name</tt> string.
+	# To express complex deletes, the regular expressions can be combined
+	# using the zoom operator (Regexp#>).
+	
+	def del(reg_exp, name = nil)
+		sub(reg_exp, '', name)
+	end #del
+	
+	
+	# Specifies a kind of substitution that inserts the <tt>text</tt> string
+	# before the first occurrence of the pattern expressed by the <tt>reg_exp</tt> regular expression. 
+	# Optionally, this substitution can be named using the <tt>name</tt> string.
+	# To express complex 'before inserts', the regular expressions can be combined
+	# using the zoom operator (Regexp#>).
+	
+	def before(reg_exp, text, name = nil)
+		sub_aux(reg_exp, text, name, 'before local')
+	end #before
+
+
+	# Specifies a kind of substitution that inserts the <tt>text</tt> string
+	# after the first occurrence of the pattern expressed by the <tt>reg_exp</tt> regular expression. 
+	# Optionally, this substitution can be named using the <tt>name</tt> string.
+	# To express complex 'after inserts', the regular expressions can be combined
+	# using the zoom operator (Regexp#>).
+	
+	def after(reg_exp, text, name = nil)
+		sub_aux(reg_exp, text, name, 'after local')
+	end #before
+
+	
+  # Specifies the change of all the occurrences of the pattern expressed by 
+	# the <tt>reg_exp</tt> regular expression to the <tt>text</tt> string. Optionally, 
+	# a substitution can be named using the <tt>name</tt> string.
+	# To build complex substitution patterns, the regular expressions can be combined
+	# using the zoom operator (Regexp#>).
+	
+	def gsub(reg_exp, text, name = nil)
+		sub_aux(reg_exp, text, name, 'global')
+	end #gsub
+	
+	
+	# Specifies a kind of substitution that deletes all the occurrence of the 
+	# pattern expressed by the <tt>reg_exp</tt> regular expression. Optionally, 
+	# this substitution can be named using the <tt>name</tt> string.
+	# To express complex deletes, the regular expressions can be combined
+	# using the zoom operator (Regexp#>).
+	
+	def gdel(reg_exp, name = nil)
+		gsub(reg_exp, '', name)
+	end #del
+	
+  
+  # Specifies a kind of substitution that inserts the <tt>text</tt> string
+	# before all the occurrences of the pattern expressed by the <tt>reg_exp</tt> regular expression. 
+	# Optionally, this substitution can be named using the <tt>name</tt> string.
+	# To express complex 'global before inserts', the regular expressions can be combined
+	# using the zoom operator (Regexp#>).def gbefore(reg_exp, text, name = nil)
+	
+	def gbefore(reg_exp, text, name = nil)
+		sub_aux(reg_exp, text, name, 'before global')
+	end #gbefore
+	
+	# Specifies a kind of substitution that inserts the <tt>text</tt> string
+	# after all the occurrences of the pattern expressed by the <tt>reg_exp</tt> regular expression. 
+	# Optionally, this substitution can be named using the <tt>name</tt> string.
+	# To express complex 'global after inserts', the regular expressions can be combined
+	# using the zoom operator (Regexp#>).def gbefore(reg_exp, text, name = nil)
+	
+	def gafter(reg_exp, text, name = nil)
+		sub_aux(reg_exp, text, name, 'after global')
+	end #before
+	
+	def ensure_sub(reg_exp, text, name) #:nodoc:
+		if text.kind_of?(String)
+			eval Error.arg_class(['reg_exp', 'Regexp'],
+						  ['text', 'String'],
+						  ['name', 'String'])
+		else #text.kind_of?(String)
+			eval Error.arg_class(['reg_exp', 'Regexp'],
+						  ['text', 'Array'],
+						  ['name', 'String'])
+		end
+	end #ensure_sub
+
+	def sub_aux(reg_exp, text, name, scope) #:nodoc:
+		ensure_sub(reg_exp, text, name)
+		@sub_hash = {} unless @sub_hash
+		name = 'anonymous_' + @sub_hash.length.to_s unless name
+		if text.kind_of?(String)
+			@sub_hash[name] = Substitution.new(reg_exp, text, scope)
+		else #text.kind_of?(Array)
+			@sub_hash[name] = Substitution.new(reg_exp, text.join("\n"), scope)
+		end
+	end #sub_aux
+	
+	
+	# Specifies the application of a set of substitutions (<tt>sub_list</tt>) on an input file (<tt>i_file</tt>) to produce an output file (<tt>o_file</tt>).
+	# * Optionally, a production can be named using the <tt>name</tt> string.
+	# * If <tt>sub_list</tt> is not specified, it will contain implicitly all the substitutions defined before the current production.
+	# * The order of the substitutions in <tt>sub_list</tt> is irrelevant.
+	# * It is posible that several substitutions of <tt>sub_list</tt> try to make different changes over the same area of the exemplar. This kind of collisions will be detected automatically calling the method <tt>prod?</tt> (internally, <tt>prod</tt> calls <tt>prod?</tt>).
+	
+	def prod(i_file, o_file, sub_list = nil, name = nil)
+		@sub_hash = {} unless @sub_hash
+		@prod_hash = {} unless @prod_hash
+		sub_list = @sub_hash.keys if !sub_list or sub_list == 'all'
+		name = 'anonymous_' + @prod_hash.length.to_s unless name
+		eval Error.arg_class(['i_file', 'String'],
+					  ['o_file', 'String'],
+					  ['sub_list', 'Array'],
+					  ['name', 'String'])
+		eval Error.without_declaration('sub')
+		eval Error.collision('prod')
+		@prod_hash[name] = Production.new(i_file, o_file, sub_list)
+	end #prod
+	
+	
+	# Returns if it is possible to execute a production (see <tt>prod</tt>)
+	
+	def prod?(i_file, o_file, sub_list = nil)
+		@sub_hash = {} unless @sub_hash
+		sub_list = @sub_hash.keys if !sub_list or sub_list == 'all'
+		eval Error.arg_class(['i_file', 'String'],
+					  ['o_file', 'String'],
+					  ['sub_list', 'Array'])
+		eval Error.without_declaration('sub')
+		return !Production.new(i_file, o_file, sub_list).crash?(@sub_hash)
+	end #prod?
+	
+	
+	# Specifies the execution of the set of productions <tt>prod_list</tt>.
+	# * If <tt>prod_list</tt> is not specified, it will contain implicitly all the productions defined before the current generation.
+	# * The order of the productions in <tt>prod_list</tt> is irrelevant.
+	# * It is posible that several substitutions included in the productions of <tt>sub_list</tt> try to make different changes over the same area of the exemplar. This kind of collisions will be detected automatically calling the method <tt>gen?</tt> (internally, <tt>gen</tt> calls <tt>gen?</tt>).
+	
+	def gen(prod_list = nil)
+
+		#####################################################
+		# <gen auxiliar methods>
+		#####################################################
+	
+		def mixGen(prod_list) #:nodoc:
+			return prod_list, @prod_hash.dup if prod_list.length == 1
+			mixedList = []
+			prod_hashMixed = @prod_hash.dup
+			0.upto(prod_list.length-2) {|i|
+				if !mixedList.include?(prod_list.at(i))
+					(i+1).upto(prod_list.length-1) {|j|
+						if !mixedList.include?(prod_list.at(j))
+							if prod_hashMixed[prod_list.at(i)].o_file == 
+								@prod_hash[prod_list.at(j)].o_file
+								mixedList.push(prod_list.at(j))
+								prod_hashMixed[prod_list.at(i)].sub_list +=
+									@prod_hash[prod_list.at(j)].sub_list
+								prod_hashMixed.delete(prod_list.at(j))
+							end
+						end #if
+					} #j
+				end #if
+			} #i
+			return prod_list-mixedList, prod_hashMixed
+		end #mixGen
+		
+		def replace(source_str, replace_list) #:nodoc:
+			delta_length = 0
+			result_str = source_str.dup			
+			replace_list.each { |rep|
+				str1 = result_str[0, rep[0] + delta_length]
+				str2 = result_str[rep[0] + delta_length, rep[1] - rep[0] +1]
+				str3 = result_str[rep[1] + 1 + delta_length, result_str.length - 1]
+				str2 =~ @sub_hash[rep[2]].reg_exp.zoom_list.last
+ 			str = ''
+				eval("str = " + '"' + @sub_hash[rep[2]].text + '"')		
+				result_str = str1 + str + str3
+				delta_length = result_str.length - source_str.length
+			}
+			return result_str
+		end
+		
+		def mix_subs(sub_list, i_file) #:nodoc:
+			result = []
+			sub_list.each { |s|
+				# local substitutions
+				if /local/ =~ @sub_hash[s].scope then
+					if /before/ =~ @sub_hash[s].scope then
+						element = @sub_hash[s].match_hash[i_file][0].dup
+						element[1] = element[0] - 1
+						element << s
+						result << element
+					elsif /after/ =~ @sub_hash[s].scope then
+						element = @sub_hash[s].match_hash[i_file][0].dup
+						element[0] = element[1] + 1
+						element << s
+						result << element
+					else
+						element = @sub_hash[s].match_hash[i_file][0].dup
+						element << s
+						result << element
+					end
+				# global substitutions
+				else
+					if /before/ =~ @sub_hash[s].scope then
+						@sub_hash[s].match_hash[i_file].each { |m|
+							element = m.dup
+							element[1] = element[0] - 1
+							element << s
+							result << element
+						}
+					elsif /after/ =~ @sub_hash[s].scope then
+						@sub_hash[s].match_hash[i_file].each { |m|
+							element = m.dup
+							element[0] = element[1] + 1
+							element << s
+							result << element
+						}
+					else
+						@sub_hash[s].match_hash[i_file].each { |m|
+							element = m.dup
+							element << s
+							result << element
+						}
+					end
+				end
+			}
+			result.sort! { |e1, e2|
+				if e1[0] == e2[0] then
+					e1[1] <=> e2[1]
+				else
+					e1[0] <=> e2[0]
+				end
+			}
+			return result
+		end
+		
+		#####################################################
+		# </gen auxiliar methods>
+		#####################################################
+		
+		@sub_hash = {} unless @sub_hash
+		@prod_hash = {} unless @prod_hash
+		prod_list = @prod_hash.keys if !prod_list or prod_list == 'all'	
+		
+		eval Error.arg_class(['prod_list', 'Array'])		
+		eval Error.without_declaration('prod')
+		eval Error.collision('gen')
+		prod_listM, prod_hashM = mixGen(prod_list)
+		
+		prod_listM.each { |p|
+			File.open(prod_hashM[p].i_file) {|f|
+				exemplar_code = f.read
+				
+				# force the match of every substitution
+				prod_hashM[p].sub_list.each {|s|
+					if !@sub_hash[s].match_hash[prod_hashM[p].i_file] then
+						@sub_hash[s].match_hash[prod_hashM[p].i_file] = @sub_hash[s].get_match_pos(exemplar_code, @sub_hash[s].reg_exp, @sub_hash[s].scope)
+					end
+				}
+		
+				exemplar_code = replace( exemplar_code, mix_subs(prod_hashM[p].sub_list, prod_hashM[p].i_file) )
+				
+				o_dir = File.dirname(prod_hashM[p].o_file)
+				begin
+					Dir.mkdir(o_dir) unless FileTest.exist?(o_dir)
+				rescue
+					if !FileTest.exist?(o_dir) then
+						operating_system_command = "`mkdir #{o_dir.gsub(/\\/, '\\\\\\')}`"
+						eval operating_system_command
+					end
+				end
+				
+				File.open(prod_hashM[p].o_file, "w+") {|o_file|
+					o_file.write(exemplar_code)
+				} #File.open(prod_hashM[p].o_file, "w+")			
+			} #File.open(prod_hashM[p].i_file) 
+		} #@prod_listM.each
+	
+	end #gen
+	
+	
+	# Returns if it is possible to execute a generation (see <tt>gen</tt>)
+	
+	def gen?(prod_list = nil)	
+		@sub_hash = {} unless @sub_hash
+		@prod_hash = {} unless @prod_hash
+		prod_list = @prod_hash.keys if !prod_list or prod_list == 'all'
+		eval Error.arg_class(['prod_list', 'Array'])		
+		eval Error.without_declaration('prod')
+		!prod_list.oneOnRest {|p1, p2|
+			@prod_hash[p1].crash?(@sub_hash, @prod_hash[p2])
+		}
+	end #gen?
+
+	
+	# Returns an array of the strings resulted on matching the <tt>reg_exp</tt> regular expression on 
+	# the input file <tt>file</tt>
+	
+	def extract(file, reg_exp)
+    eval Error.arg_class(['file', 'String'], ['reg_exp', 'Regexp'])
+    result = []
+		file_code = ''
+		pos = []
+		File.open(file) {|file|
+			file_code = file.read
+			s = Substitution.new(//,'','global')
+			pos = s.get_match_pos(file_code, reg_exp, s.scope)
+		}
+		pos.each { |p|
+			result << file_code[p[0], p[1] - p[0] + 1]
+		}
+		return result
+	end
+  
+	
+  # Returns an array of the strings grouped by the parenthesis <tt>number</tt> when the <tt>reg_exp</tt> regular expression is matched on 
+	# the input <tt>file</tt>.
+  #
+  # For example. if the content of <tt>myfile.txt</tt> is:
+  #
+  # <tt>This is my code</tt>
+  # 
+  # The result of execute:
+  #
+  # <tt>g = generator</tt>
+  #
+  # <tt>puts "$1 = " + g.extract_dollar('myfile.txt', /(This).*?(code).*?/, 1).to_s</tt>
+  #
+  # <tt>puts "$2 = " + g.extract_dollar('myfile.txt', /(This).*?(code).*?/, 2).to_s</tt>
+  #
+  # would be
+  #
+  # <tt>$1 = This</tt>
+  #
+  # <tt>$2 = code</tt>
+  
+  def extract_dollar(file, reg_exp, number)
+    eval Error.arg_class(['file', 'String'], ['reg_exp', 'Regexp'], ['number', 'Integer'])
+    
+    result = []
+		file_code = ''
+		pos = []
+		File.open(file) {|file|
+			file_code = file.read
+			s = Substitution.new(//,'','global')
+			pos = s.get_match_pos(file_code, reg_exp, s.scope)
+		}
+		pos.each { |p|
+      file_code[p[0], p[1] - p[0] + 1] =~ reg_exp.zoom_list.last
+      eval "result << $#{number}"
+		}
+		return result
+	end
+  
+
+	def rename #:nodoc:
+		result = Generator.new
+		result.sub_hash = @sub_hash.my_collect { |key, value|
+			["#{key}__#{self.class}: #{self.object_id}", value]
+		}
+		result.prod_hash = @prod_hash.my_collect { |key, value|
+			key = "#{key}__#{self.class}: #{self.object_id}"
+			value.sub_list.collect! {|element|
+				"#{element}__#{self.class}: #{self.object_id}"
+			}
+			[key, value]
+		}
+		return result
+	end #rename
+
+	
+	# Adds <tt>self</tt> and <tt>generator</tt>. Returns a new Generator which substitutions and productions are the union
+	# of the substitutions and the productions of <tt>self</tt> and <tt>generator</tt>.
+	# Collisions between the substitutions of <tt>self</tt> and <tt>generator</tt> will be detected automatically calling the method <tt>add?</tt> (internally, + calls <tt>add?</tt>)
+	
+	def +(generator)
+		eval Error.arg_class(['generator', 'Generator'])		
+		eval Error.collision('add')
+		gen1 = rename
+		gen2 = generator.rename
+		return gen1 << gen2
+	end #+
+	
+
+	# Prefix notation for +
+
+	def add(generator)
+		self + generator
+	end #add
+	
+	
+	# Returns if it is possible to add <tt>self</tt> and <tt>generator</tt> (see + and <tt>add</tt>)
+
+	def add?(generator)
+		eval Error.arg_class(['generator', 'Generator'])		
+		gen1 = rename
+		gen2 = generator.rename
+		gen1.sub_hash.update(gen2.sub_hash)
+		gen1.prod_hash.each_value {|p1|
+			gen2.prod_hash.each_value {|p2|
+				return false if p1.crash?(gen1.sub_hash, p2)
+			} #prod_hash2
+		} #prod_hash1
+		return true
+	end #add?
+
+
+	# Superpose <tt>generator</tt> to <tt>self</tt>. << actualizes the substitutions and productions of <tt>self</tt> with the substitutions and productions of <tt>generator</tt>.
+	# The substitutions and productions of <tt>generator</tt> with a common name in <tt>self</tt> are overwritten in <tt>self</tt>.
+	# The others are added to <tt>self</tt>.
+	# Collisions between the substitutions of <tt>self</tt> and <tt>generator</tt> will be detected automatically calling the method <tt>sup</tt> (internally, << calls <tt>sup?</tt>)
+	
+	def <<(generator)
+		eval Error.arg_class(['generator', 'Generator'])		
+		eval Error.collision('sup')
+		@sub_hash.update(generator.sub_hash)
+		@prod_hash.update(generator.prod_hash)
+		return self
+	end #<<
+
+	
+	# Prefix notation for <<
+	
+	def sup!(generator)
+		self << generator
+	end #sup!
+
+	
+	# Returns if it is possible to superpose <tt>self</tt> to <tt>generator</tt> (see << and <tt>sup!</tt>)
+
+	def sup?(generator)
+		eval Error.arg_class(['generator', 'Generator'])		
+		sub_hashAux = @sub_hash.dup.update(generator.sub_hash)
+		generator.prod_hash.each { |k1, v1|
+			@prod_hash.each { |k2, v2|
+				if (k1 != k2) && (v1.crash?(sub_hashAux, v2))
+					return false
+				end
+			}
+		}
+		return true
+	end #sup?
+	
+  
+  public	:sub, :del, :before, :after, :gsub, :gdel, :gbefore, :gafter, :prod, :prod?, :gen, :gen?, :extract, :extract_dollar, :+, :add, :add?, :<<, :sup!, :sup? 
+  protected :sub_aux, :ensure_sub, :rename
+	
+end #Generator
+