aml 0.0.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6aea97c2f4ce5ca6518bc5f0a54413a51098a30b
-  data.tar.gz: ef5e7c9a1c398c09f1313c0ca07cba424e80588f
+  metadata.gz: 62586a90cf259bfb9db8e6144d6b617eac6f62f7
+  data.tar.gz: 83cd34500258139d04cfd6d91a484ff53aa62fcc
 SHA512:
-  metadata.gz: 6747afed28caae4c3d0b61bd0e3e3498003eb62391ee782911b4b2a76a7c0c0483be45218ce168f8bf6520e90fc7af1d43291422565e612342b67c5dc0c0e1ac
-  data.tar.gz: fa599c7bd3abd6da2f014ada6adec3251fe1e87d6dc84dad263fc7e5ae6c4415c4aaf413cea8f4e0a785e7c27e5032bf33591328d3052e5f57188497cf1c1417
+  metadata.gz: f6a5e3848de3b9e91245fcfeb9d74546f38816e285d794601d59461f9dda536ae8ff427c6b0bea8bfa4001657ba8982890808f50786d5a2cfa34942b699dd544
+  data.tar.gz: 4ec08e0e48c78777aeda9ffe8563d448e9ee42988e41be19149f87fa5a917a107c399108a7eea97c89665de1562b1e4513210eceafd06b20f9264465496b3516

data/bin/aml

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'aml'
+AbstractMarkupLanguage::Base.initialize(ARGV.join(' '))

data/lib/aml.rb

@@ -1,5 +1,67 @@
-class Aml
-  def self.hi
-    puts "Hello world!"
-  end
-end
+module AbstractMarkupLanguage
+	class Base
+		@@args = {}
+		@@args_original = ''
+		@@watch = false
+		@@p = false
+
+		def self.initialize(arguments)
+			log = Log.new('The following errors have occured:')
+			argument = Argument.new(arguments)
+			@@args_original = arguments
+			argument.required('watch','The required --watch attribute has not been defined.')
+			if(argument.has_requirements?)
+				if File.exist?(argument.read('watch'))
+					basePath = File.dirname(argument.read('watch'))
+					argument.create('watch',"#{File.basename(argument.read('watch'))}")
+					argument.create_if_empty('basePath',basePath)
+					argument.create_if_empty('fileExtension','html')
+					argument.create_if_empty('fileOutput',"#{File.basename(argument.read('watch'), ".*")}.#{argument.read('fileExtension')}")
+					argument.create_if_empty('selfClosing',"area,base,basefont,bgsound,br,col,frame,hr,img,isindex,input,keygen,link,meta,param,source,track,wbr")
+					argument.create_if_empty('sortAttribute','true')
+					argument.create_if_empty('singleQuote','false')
+					@@args = argument.hash
+					@@p = Parse.new(@@args)
+					process
+				else
+					log.add('The file to watch does not exist.')
+					argument.missing_required.each do |message|
+						log.add(message)
+					end
+					log.display
+				end
+			else
+				argument.missing_required.each do |message|
+					log.add(message)
+				end
+				log.display
+			end
+		end
+		def self.process
+			file = []
+			@@watch = Watch.new()
+			parse  = Parse.new(@@args)
+			file << File.join(@@args[:basePath],@@args[:watch])
+			parse.process_partials(File.join(@@args[:basePath],@@args[:watch])).each do |partial|
+				partial_file = File.join(@@args[:basePath],"~","#{partial[:name]}.aml")
+				file << partial_file if File.exist?(partial_file)
+			end
+			@@watch.process(file)
+			message = "Watching #{file[0]}"
+			message += " and #{file.count-1} partial" if file.count >= 2
+			message += "s" if file.count >= 3
+			message += "...\r\n"
+			puts message
+			@@watch.watch
+		end
+
+		def file_update(name)
+			puts "updating #{@@args[:watch]} - #{name} has been updated..."
+			@@p.init(File.join(@@args[:basePath],@@args[:watch]),@@args)
+		end
+	end
+end
+require 'aml/argument'
+require 'aml/log'
+require 'aml/watch'
+require 'aml/parse'

data/lib/aml/argument.rb

@@ -0,0 +1,65 @@
+class Argument
+	
+	@@argumental = {}
+	@@required = {}
+	
+	def initialize(arguments)
+		arguments = arguments.split('--')
+		arguments.each do |argument|
+			string = argument.split(' ')
+			create(string[0],string[1..string.count].join(' ')) if argument.strip.length > 0
+		end
+	end
+
+	def hash
+		return @@argumental
+	end
+
+	def required(name,message)
+		@@required[name.to_sym] = {:message=>message.strip, :defined=>false}
+	end
+
+	def has_requirements?
+		@@required.each do|key,hash|
+			hash[:defined] = true if(@@argumental.select{|k,v| k.to_s == key.to_s}.count == 1)
+		end
+		@@required.select{|k,v| v[:defined] == false}.count == 0 ? true : false
+	end
+
+	def missing_required
+		message = []
+		@@required.select{|k,v| v[:defined] == false}.each do |attribute,hash|
+			message << hash[:message]
+		end
+		message
+	end
+	
+	def create(name,value)
+		@@argumental[name.to_sym] = value.strip if(value.length > 0)
+	end
+
+	def create_if_empty(name,value)
+		create(name,value) if @@argumental.select{|k,v| k.to_s == name}.count == 0
+	end
+
+	def read(name)
+		@@argumental[name.to_sym]
+	end
+
+	def update(name,value)
+		create(name,value)
+	end
+
+	def update_append(name,value)
+		create(name,"#{value}#{read(name)}")
+	end
+
+	def update_prepend(name,value)
+		create(name,"#{read(name)}#{value}")
+	end
+
+	def delete(name)
+		@@argumental = @@argumental.select{|k,v| k.to_s != name}
+	end
+
+end

data/lib/aml/log.rb

@@ -0,0 +1,25 @@
+class Log
+	
+	@@introduction = false
+	@@message = []
+	
+	def initialize(introduction=false)
+		@@introduction = introduction
+	end
+
+	def introduction(message)
+		@@introduction = message
+	end
+
+	def add(message)
+		@@message << message
+	end
+
+	def display(introduction=true)
+		puts @@introduction if(@@introduction != false) and introduction
+		@@message.each do |message|
+			puts "- #{message}"
+		end
+	end
+
+end

data/lib/aml/parse.rb

@@ -0,0 +1,504 @@
+class Parse
+	@@aml = {
+		:argumenthash => {},
+		:argument	=>	{
+			:tag_attribute_sort 		=>	true,
+			:tag_attribute_double_quote	=>	true
+		},
+		:regex	=>	{
+			:tag		=>	/(?<!%)%([\w|-]+)([#|\.|][\w|-]+)?([#|\.|][\w|-]+)?(\/)?(\{.+\})?(.+)?/,
+			:mixin		=>	/%\(([^~][\w|-]+)\)(\{.+\})?[^\{]?/,
+			:partial	=>	/(%)\(\~([\w|-]+)\)/,
+			:def_mixin	=>	/^%%([^-][\w|-]+)(\(.+\))?\{/,
+			:end_mixin	=> 	/^\}$/,
+			:def_var	=>	/^\s*?\@(\w+)\s?=\s?(.+)(?=$)/,
+			:package	=>	/^::([\w|-]+)(\{(.+?)\})?$/,
+			:empty		=>	/^$/,
+			:string		=>	//
+		},
+		:argument	=>	/@\(\:(\w+)\)/,
+		:variable	=>	{
+			:store	=>	[],
+			:regex	=>	/\@\((\w+)(?=\))\)/
+		},
+		:threeline	=>	/<(.+)(\s.+?)?>\r\n\t{1,}(.+)\n\t{1,}<\/\1>/,
+		:comment 	=>	{
+			:store	=>	[],
+			:regex	=>	/\s?%!--([^$]+?)--%/
+		},
+		:file	=>	{
+			:name	=>	nil,
+			:param	=>	{},
+			:path	=>	'',
+			:index	=>	0
+		},
+		:log	=>	{
+			:error		=>	[],
+			:warning	=>	[]
+		},
+		:struct	=>	{
+			:file		=>	[],
+			:mixin		=>	[],
+			:markup		=>	[],
+			:partial	=>	[],
+			:selftag	=>	['area','base','basefont','bgsound','br','col','frame','hr','img','isindex','input','keygen','link','meta','param','source','track','wbr']
+		}
+	}
+
+	def initialize(args={})
+		@@aml[:argumenthash] = args
+	end
+
+	def init(file=nil,args={},index=0,output_to_file=false)
+		file_read(file)
+		@@aml[:file][:path] = File.dirname(file)
+		variable_structure
+		partial_structure
+		##package_structure
+		mixin_structure
+		markup_structure
+        markup_structure_block
+        @@aml[:argumenthash] = args
+	end
+
+	def file_read(file)
+		clean_structures
+		line = 0
+		File.open(file,"r").each_line do |string|
+			file_structure(line+=1,string)
+		end
+		#puts @@aml[:struct][:file]
+	end
+
+	def clean_structures
+		@@aml[:variable][:store] =	[]
+		@@aml[:struct] = {
+			:file		=>	[],
+			:mixin		=>	[],
+			:markup		=>	[],
+			:partial	=>	[],
+			:selftag	=>	['area','base','basefont','bgsound','br','col','frame','hr','img','isindex','input','keygen','link','meta','param','source','track','wbr']
+		}
+	end
+
+	def file_structure(line,string,baseIndex=0)
+		type = false
+		@@aml[:regex].each do |line_type,regex|
+			if(string.match(regex))
+				type = line_type.to_s
+				break
+			end
+		end
+		@@aml[:struct][:file] << {:line => line, :type => type, :index => string.match(/^\t{0,}/).to_s.length+baseIndex, :within_mixin => false, :string => string.strip}
+	end
+
+	def variable_structure
+		@@aml[:struct][:file].each do |line|
+			if line[:string].to_s.length > 0
+				match = line[:string].match(@@aml[:regex][:def_var])
+				@@aml[:variable][:store] << {:line => line[:line], :name => match[1], :value => match[2]} if match
+			end
+		end
+		variable_structure_replacements
+		variable_structure_string_lines
+	end
+
+	def variable_structure_replacements
+		@@aml[:struct][:file].each do |line|
+			if line[:string].to_s.length > 0
+				if(line[:string].match(@@aml[:variable][:regex]))
+					line[:string] = line[:string].gsub(@@aml[:variable][:regex], @@aml[:variable][:store].select{|k|k[:name] == "#{$1}" and k[:line] <= line[:line]}.last[:value])
+				end
+			end
+		end
+	end
+
+	def variable_structure_string_lines
+		@@aml[:struct][:file].each do |line|
+			if(line[:type] == 'string')
+				string = "#{line[:string]}"
+				type = false
+				@@aml[:regex].each do |line_type,regex|
+					if(line[:string].match(regex))
+						type = line_type.to_s
+						break
+					end
+				end
+				line[:type] = type
+				line[:string] = string
+			end
+		end
+	end
+
+	def partial_structure
+		@@aml[:struct][:file].each do |line|
+			if(line[:type] == 'partial')
+				match = line[:string].match(@@aml[:regex][:partial])
+				if(@@aml[:struct][:partial].select{|k|k[:name] == match[2]}.count == 0)
+					@@aml[:struct][:partial] << {
+						:name	=>	match[2],
+						:path	=>	File.join(@@aml[:file][:path],'~'),
+						:exists	=>	File.exist?("#{File.join(@@aml[:file][:path],'~','')}#{match[2]}.aml")
+					}
+				end
+			end
+		end
+		#puts "----- Partials"
+		#puts @@aml[:struct][:partial]
+		#puts "-----"
+	end
+
+
+	def mixin_structure
+		@@aml[:struct][:file].each do |line|
+			if(line[:type] == 'def_mixin')
+				match = line[:string].match(@@aml[:regex][:def_mixin])
+				@@aml[:struct][:mixin][@@aml[:struct][:mixin].count] = {:name => match[1], :param => match[2].nil? ? false : eval("{#{match[2][1..-2]}}"), :begin_def => line[:line], :end_def => nil}
+			elsif(line[:type] == 'end_mixin')
+				@@aml[:struct][:mixin][@@aml[:struct][:mixin].count-1][:end_def] = line[:line]
+			end
+		end
+		mixin_structure_build
+	end
+
+	def mixin_structure_build
+		@@aml[:struct][:mixin].each_with_index do |mixin,i|
+			within_mixin = @@aml[:struct][:file][mixin[:begin_def]..mixin[:end_def]-2]
+			within_mixin.each do |line|
+				line[:within_mixin] = true
+			end
+			@@aml[:struct][:mixin][i][:struct] = within_mixin
+		end
+	end
+
+	def markup_structure
+		#file_structure(@aml[:struct][:file].count+1,"\r\n") if(@aml[:struct][:file].last[:index] == 0)
+		@@aml[:struct][:file].each do |line|
+			if(line[:within_mixin] == false)
+				markup_line = line.clone
+				case line[:type]
+				when 'tag'
+					markup_structure_line_tag(markup_line,line[:index])
+				when 'string'
+					markup_structure_line_string(markup_line,line[:index])
+				when 'mixin'
+					markup_structure_line_mixin(markup_line,line[:index])
+				when 'partial'
+					markup_structure_line_partial(markup_line,line[:index])
+				end
+			end
+		end
+	end
+
+	def markup_structure_line_tag(line,baseIndex)
+		if line[:string].to_s.length > 0
+			match = line[:string].match(@@aml[:regex][:tag])
+			data = line.merge({:selftag => match[4].nil? == false, :param => match[5].nil? ? {} : eval("#{match[5]}"), :match => match[1..-2]})
+			data[:param]["#{data[:match][1][0] == '#' ? 'id' : 'class'}".to_sym] = data[:match][1][1..-1] if(data[:match][1])
+			data[:param]["#{data[:match][2][0] == '#' ? 'id' : 'class'}".to_sym] = data[:match][2][1..-1] if(data[:match][2])
+			@@aml[:struct][:selftag].each do|tag|
+				if(match[1] == tag)
+					data[:selftag] = true
+					break
+				end
+			end
+			@@aml[:struct][:markup] << data
+			if(match[6].nil? == false) then
+				@@aml[:struct][:markup] << {:line => line[:line], :type=> 'string', :index => line[:index]+1, :within_mixin => line[:within_mixin], :string => "#{match[6].to_s.strip!}", :selftag => true, :match => []}
+			end
+
+		end
+	end
+
+	def markup_structure_line_string(line,baseIndex)
+		#line[:string] = line[:string].gsub(@aml[:argument], get_argument_for(line,"#{$1}").to_s) if(line[:within_mixin] and line[:string].to_s.length > 0 and line[:string].match(@aml[:argument]))
+		if(line[:within_mixin] and line[:string].to_s.length > 0)
+			line[:string] = line[:string].gsub(@@aml[:argument]){|m|get_argument_for(line, "#{$1}".to_s)}
+		end
+        @@aml[:struct][:markup] << line.merge({:param => false, :selftag => true, :match => []})
+	end
+
+	def markup_structure_line_mixin(line,baseIndex)
+		#puts "#{line[:string]} - #{baseIndex}"
+		match = "#{line[:string]}".match(@@aml[:regex][:mixin])
+		param = match[2].nil? ? false : eval("{#{match[2][1..-2]}}")
+		exists = false
+		@@aml[:struct][:mixin].each do |mixin_index|
+			if(mixin_index[:name] == match[1])
+				mixin_index[:struct].each do |mixin_line|
+					markup_line = mixin_line.clone
+					markup_line[:index] = (markup_line[:index]-1) + line[:index]
+
+					markup_line[:mixin] = {
+						:name => mixin_index[:name],
+						:param => param
+					}
+
+					markup_line[:string] = markup_line[:string].gsub(@@aml[:argument]){|m|get_argument_for(markup_line, "#{$1}".to_s)}
+
+					case markup_line[:type]
+					when 'tag'
+						markup_structure_line_tag(markup_line,markup_line[:index])
+					when 'string'
+						markup_structure_line_string(markup_line,markup_line[:index])
+					when 'mixin'
+						markup_structure_line_mixin(markup_line,markup_line[:index])
+					when 'partial'
+						markup_structure_line_partial(markup_line,markup_line[:index])
+					end
+				end
+				exists = true
+				break
+			end
+		end
+		if(exists == false)
+			#log('warning', "The mixin <#{match[1]}> called on line <#{line[:line]}> does not exist")
+		end
+	end
+
+	def markup_structure_line_partial(line,baseIndex)
+		match = line[:string].match(@@aml[:regex][:partial])
+		if(@@aml[:struct][:partial].select{|k|k[:name]==match[2]}.count == 1)
+			partial = @@aml[:struct][:partial].select{|k|k[:name]==match[2]}.first
+			if partial[:exists]
+				line = 0
+				File.open(File.join("#{partial[:path]}","#{partial[:name]}.aml"),"r").each_line do |string|
+					file_structure(line+=1,string,baseIndex)
+				end
+			else
+				#log('warning', "The partial <#{match[2]}> called on line <#{line[:line]}> does not exist in path <#{partial[:path]}>.")
+			end
+		end
+	end
+
+	def get_argument_for(line,argument)
+		value = line[:mixin][:param].select{|k,x|k.to_s==argument}[argument.to_sym] if(line.has_key?(:mixin) and line[:mixin].has_key?(:param) and line[:mixin][:param] != false)
+		value = @@aml[:struct][:mixin].select{|k| line[:mixin][:name] == k[:name] and line[:line] > k[:begin_def] and line[:line] < k[:end_def]}.last[:param].select{|k,x|k.to_s==argument}[argument.to_sym] if(value.nil?)
+		return value
+	end
+
+	def hash_to_attribute(hash)
+		attribute = hash_to_attribute_build(hash).strip
+		attribute = " #{attribute}" if(attribute.length > 0)
+	end
+
+	def hash_to_attribute_build(hash,base="")
+		hash = hash.sort_by{|key, value| key}
+		string = ""
+		hash.each do |key, value|
+			if(value.is_a?(Hash))
+				value.sort_by{|key, value| key}
+				string << "#{hash_to_attribute_build(value,"#{base}#{key}-")} "
+			else
+				string << "#{base}#{key}=\"#{value}\" "
+			end
+		end
+		string.strip
+	end
+
+	def close_open_tag(open_tag,close=[])
+    	if(open_tag.count >= 2)
+	    	if(open_tag[0][:tag] == open_tag[1][:tag])
+	    		if(open_tag[0][:closing] == false and open_tag[1][:closing] != open_tag[0][:closing])
+	    			close_open_tag(open_tag[2...open_tag.count],close)
+	    		else
+					close << open_tag[0]
+					close_open_tag(open_tag[1...open_tag.count],close)
+				end
+			else
+				close << open_tag[0]
+				close_open_tag(open_tag[1...open_tag.count],close)
+			end
+		else
+			close << open_tag[0] if(open_tag.count == 1)
+		end
+		close
+    end
+
+	def close_tags(output,high_index_force=false)
+    	high_index = 0
+    	if(high_index_force != false)
+    		high_index = high_index_force
+    	else
+    		output.each do |line|
+    			high_index = line[:index] if(line[:index] > high_index and line[:tag] != false)
+    		end
+    	end
+    	open_tag = []
+    	output.each_with_index do |line,index|
+    		if(line[:index] == high_index and line[:tag] != false)
+    			line[:number] = index
+    			open_tag << line
+    		end
+    	end
+    	tags_to_close = close_open_tag(open_tag)
+    	offset = 0
+    	tags_to_close.reverse.each do |line|
+    		closeTag = line
+    		output.each_with_index do |line,index|
+	    		if(index > closeTag[:number])
+	    			if(line[:index] == closeTag[:index] or line[:index] <= closeTag[:index]-1)
+	    				output.insert(index, {:index => closeTag[:index], :tag => closeTag[:tag], :string => "</#{closeTag[:tag]}>"})
+	    				break
+	    			end
+	    		end
+	    	end
+    	end
+    	if(high_index > 1)
+    		output = close_tags(output,high_index-1)
+    	end
+    	output
+    end
+
+
+
+    def markup_structure_block
+    	#@@aml[:struct][:markup].each do |line|
+    		#puts "#{'	'*line[:index]}#{line[:string]}\r\n"
+    	#end
+
+        markup = []
+        @@aml[:struct][:markup].each_with_index do |line,i|
+            string = ""
+            tag = false
+            if(line[:match][0].nil?) then
+                string = line[:string]
+           	else
+                tag = line[:match][0]
+                selftag = ''
+                selftag = ' /' if(line[:selftag] and @@aml[:struct][:selftag].include? line[:match][0])
+                string = "<#{line[:match][0]}#{hash_to_attribute(line[:param])}#{selftag}>"
+            end
+            markup << {:line => i+1, :index => line[:index], :tag => (line[:selftag]) ? false : tag, :string => string}
+	    end
+        @@aml[:struct][:markup] = markup
+        markup = []
+        @@aml[:struct][:markup] = markup_block
+
+        output = ''
+        @@aml[:struct][:markup].each do |block|
+			block = markup_block_resursive(block[:block]).reverse
+			output += markup_block_group(block).to_s + "\r\n"
+       	end
+       	File.open("#{File.join(@@aml[:argumenthash][:basePath],@@aml[:argumenthash][:fileOutput])}", 'w'){|f| f.write(output.strip!)}
+    end
+
+    def markup_block(begin_line=0,struct=[])
+    	def_block = []
+    	end_block = false
+    	index_one = false
+    	end_line = begin_line
+    	@@aml[:struct][:markup].each_with_index do |line,i|
+    		if(line[:line] >= begin_line and end_block == false)
+    			index_one = true if(line[:index] > 0)
+    			end_block = true if(line[:index] == 0 and index_one)
+    			if(end_block == false)
+    				def_block << line
+    				end_line = line[:line]
+    			end
+    		else
+    			@@aml[:struct][:markup].delete_if{|x| x[:line] <= end_line}
+    			break
+    		end
+    	end
+    	if(@@aml[:struct][:markup].count > 0 and @@aml[:struct][:markup].select{|k|k[:line]}.last[:line] > end_line)
+    		markup_block(end_line+1,struct)
+    	end
+    	struct << {:line => {:begin=>begin_line, :end => end_line}, :block => def_block}
+    	struct.flatten.reverse
+    end
+
+    def markup_block_resursive(markup,struct=[])
+    	def_block = []
+    	last_index = 0
+    	markup.each do |line|
+    		if(line[:index] >= last_index)
+    			def_block << line
+    			last_index = line[:index]
+    		else
+    			markup_block_resursive(markup.select{|k|k[:line]>=line[:line]},struct)
+    			break
+    		end
+    	end
+    	struct << def_block
+    end
+
+    def markup_block_group(blocks)
+    	#puts blocks
+    	#puts "-"
+    	output = []
+    	zeroIndex = []
+    	lastLine = false
+    	blocks.each_with_index do |block,index|
+
+    		block.each_with_index do |line,i|
+    			if(line[:index]>0)
+    				#set next line
+    				nextLine = false
+    				nextLine = block[i+1] if(block.count > i+1)
+    				output << {:index => line[:index], :tag => line[:tag], :closing => false, :string => line[:string]}
+    				#close tags on same index
+    				if(nextLine and nextLine[:index] == line[:index])
+    					output << {:index => line[:index], :tag => line[:tag], :closing => true, :string => "</#{line[:tag]}>"} if(line[:tag] != false)
+    					line[:tag] = false
+    				end
+
+    			else
+    				#add line to zeroIndex, close tags in reverse order
+    				output << {:index => line[:index], :tag => line[:tag], :closing => false, :string => line[:string]}
+    				#line[:tag] = false
+    				zeroIndex << line
+
+    				if(lastLine and lastLine[:index] == 0)
+    					output << {:index => lastLine[:index], :tag => lastLine[:tag], :closing => true, :string => "</#{lastLine[:tag]}>"} if(lastLine[:tag] != false)	
+    					lastLine[:tag] = false
+    				end
+    			end
+    			lastLine = line
+    		end
+
+    	end
+
+    	#close zero index tags
+    	zeroIndex = zeroIndex.drop(zeroIndex.count-1) if @@aml[:struct][:file].select{|k|k[:index] != 0}.count == 0
+    	zeroIndex.reverse.each do |line|
+    		output << {:index => line[:index], :tag=> line[:tag], :closing => true, :string => "</#{line[:tag]}>"} if(line[:tag] != false and line[:index] == 0)
+    	end
+
+    	#go up the chain in reverse (recursive) to find unclosed tags
+    	output = close_tags(output)
+    	sout = ""
+    	output.each do |line|
+    		sout += "#{'	'*line[:index]}#{line[:string]}\r\n"
+    	end
+    	sout.strip!
+    end
+
+
+
+
+
+
+
+	def process_package
+	end
+
+	def process_partials(file)
+		partial = []
+		File.open(file,"r").each_line do |string|
+			type = false
+			@@aml[:regex].each do |line_type,regex|
+				if(string.match(regex))
+					type = line_type.to_s
+					break
+				end
+			end
+			if(type == 'partial')
+				match = string.match(@@aml[:regex][:partial])
+				partial << {:name=>match[2]}
+			end
+		end
+		partial
+	end
+
+end

data/lib/aml/watch.rb

@@ -0,0 +1,37 @@
+class Watch
+	def initialize
+	end
+
+	def process(filenames)
+		filenames = [filenames] if(filenames.kind_of?String)
+    	@last_mtimes = {}
+    	filenames.each do |filename|
+    		@last_mtimes[filename] = File.stat(filename).mtime
+    	end
+    	@filenames = filenames
+    end
+    
+	def watch(sleep=1)
+		loop do
+			begin
+				Kernel.sleep sleep until file_updated?
+			rescue SystemExit,Interrupt
+				puts "\r\n"
+				Kernel.exit
+			end
+		end
+	end
+
+	def file_updated?
+		@filenames.each do |filename|
+			mtime = File.stat(filename).mtime
+			updated = @last_mtimes[filename] < mtime
+			@last_mtimes[filename] = mtime
+			if(updated)
+				AbstractMarkupLanguage::Base.new.file_update(filename)
+				return true
+			end
+		end
+		return false
+	end
+end

metadata

@@ -1,24 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: aml
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.2
 platform: ruby
 authors:
 - Daniel Esquivias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-15 00:00:00.000000000 Z
+date: 2013-05-07 00:00:00.000000000 Z
 dependencies: []
-description: A simple abstract (x)html markup language focused on static (x)html file
-  genaration.
-email: daniel.esquivias@gmail.com
-executables: []
+description: Abstract Markup Language is a robust and feature rich markup language
+  designed to avoid repetition and promote clear, well-indented markup.
+email: daniel@aml-info.org
+executables:
+- aml
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/aml.rb
-homepage: http://rubygems.org/gems/aml
+- lib/aml/argument.rb
+- lib/aml/log.rb
+- lib/aml/watch.rb
+- lib/aml/parse.rb
+- bin/aml
+homepage: https://aml-info.org/
 licenses:
 - MIT
 metadata: {}
@@ -30,7 +36,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -38,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Abstract Markup Language