aml 0.0.2 → 0.0.3

data/lib/aml/parse.rb

@@ -1,504 +1,70 @@
 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 file
+		return @file
+	end
+	def watch
+		return @watch
+	end
+	def initialize(path, file)
+		@path	=	path
+		@regex	=	{
+			:attribute		=>	/@\(\:(?<name>[\w|\-]+)\)/,
+			:comment		=>	/%!--[^%]*--%$/,
+			:variable		=>	/\@\(((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)/,
 		}
-	}
-
-	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']
+		@types	=	{
+			:method			=>	LineType.new(/^(\s{1,})?::((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)(\{(?<attributes>.+)\})?/),
+			:variable_def	=>	LineType.new(/^(\s{1,})?\@((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\s?(\=)\s?(?<value>.+)?$/),
+			:mixin			=>	LineType.new(/^(\s{1,})?%\(((?<bundle>[\w|\-]+)\.)?(?<name>[^~][\w|\-]+)\)(\{(?<attributes>.+)\})?[^\{]?/),
+			:mixin_def		=>	LineType.new(/^%%(?<name>[\w|\-]+)(\((?<attributes>.+?)\))?{/),
+			:mixin_end		=> 	LineType.new(/^\}$/),
+			:partial		=>	LineType.new(/^(\s{1,})?%\(\~((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)(\{(?<attributes>.+)\}[^\{]?)?$/),
+			:tag			=>	LineType.new(/^(\s{1,})?(?<!%)%(?<close>\/{0,2})?(?<name>[\w|\-]+)(\#(?<id_first>[\w|\-]+))?(?<class>(\.[\w|\-]+)?{1,})?(\#(?<id_last>[\w|\-]+))?(\{(?<attributes>.+)\})?(?<text>.+)?/),
+			:empty			=>	LineType.new(/^$/),
+			:eval			=>	LineType.new(/^(\s{1,})?==(\s{1,})(?<value>.+)?/),
+			:string			=>	LineType.new(/(\s{1,})?(?<value>.+)?/)
 		}
-	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
+		@file	=	{}
+		@watch	=	[]
+		read(file, false)
+	end
+	def read(file, partial)
+		line_number = 0
+		line_struct = []
+		File.open(File.join(@path,file)).read.gsub(@regex[:comment],'').each_line do |line|
+			@types.each do |type, line_type|
+				if match = line_type.match?(line)
+					struct = Hash[match.names.zip(match.captures)]
+					struct = Hash[struct.map{|(k,v)| [k.to_sym,v]}]
+					struct[:index] = line.match(/^\t{0,}/).to_s.length
+					struct[:number] = line_number+=1
+					struct[:type] = type
+					match.names.each do |name|
+						struct[name.to_sym] = line_type.send(name.to_s, match)
 					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])
+					if struct[:name].to_s[0,1] == '.'
+						#set undefined bundle
+						struct[:bundle] = 'core'
+						struct[:name] = struct[:name][1,struct[:name].length] 
 					end
+					struct[:bundle] = false if struct[:bundle].to_s.length == 0
+					#set undefined method bundle
+					struct[:bundle] = 'core' if struct[:type] == :method and !struct[:bundle]
+					struct[:id] = struct[:id_first].to_s.length > 0 ? struct[:id_first] : struct[:id_last]
+					struct.delete(:id_first)
+					struct.delete(:id_last)
+					line_struct << Hash[struct.sort] if struct[:type] != :empty
+					break
 				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
+		@file = {:name => file, :line => line_struct}
+		@watch << {:file => file, :bundle => false, :partial => false}
+		partial_watch(line_struct)
 	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
+	def partial_watch(struct)
+		struct.reject{|k,v| k[:type] != :partial}.each do |partial|
+			@watch << {:file => "#{partial[:name]}.aml", :bundle=> partial[:bundle], :partial => true}
 		end
-		partial
 	end
-
 end

data/lib/aml/requirement.rb

@@ -0,0 +1,8 @@
+require 'aml/error'
+require 'aml/argument'
+require 'aml/line_type'
+require 'aml/parse'
+require 'aml/watch'
+require 'aml/definition'
+require 'aml/make'
+require 'aml/compile'

data/lib/aml/watch.rb

@@ -1,34 +1,33 @@
 class Watch
-	def initialize
-	end
-
-	def process(filenames)
+	def initialize(filenames, arguments, instance, build)
+		@arguments = arguments
+		@instance = instance
 		filenames = [filenames] if(filenames.kind_of?String)
-    	@last_mtimes = {}
-    	filenames.each do |filename|
-    		@last_mtimes[filename] = File.stat(filename).mtime
-    	end
-    	@filenames = filenames
-    end
-    
+		@last_mtimes = {}
+		filenames.each do |filename|
+			@last_mtimes[filename] = File.stat(filename).mtime
+		end
+		@filenames = filenames
+		watch
+	end
 	def watch(sleep=1)
 		loop do
 			begin
 				Kernel.sleep sleep until file_updated?
-			rescue SystemExit,Interrupt
-				puts "\r\n"
+				rescue SystemExit,Interrupt
+				puts ""
 				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)
+				exec("aml #{@arguments} --aml-watch-instance #{@instance}")
+				Kernel.exit
 				return true
 			end
 		end

data/lib/aml-bundle.rb

@@ -0,0 +1,58 @@
+require "awesome_print"
+require 'fileutils'
+require 'aml/argument'
+module AbstractMarkupLanguage
+	class Bundle
+		def self.initialize(arguments)
+			argument = Argument.new(arguments)
+			#argument.create_action('create')
+			#argument.create_action('install')
+			#argument.create_action('update')
+			#argument.create_action('delete')
+			
+			
+			
+			argument.required('name','The required --name argument has not been defined.')
+			if argument.has_requirements?#and directory exists false?)
+				basePath = File.dirname('~')
+
+				argument.create_if_empty('--','bundle')
+
+				#aml-bundle install
+				#aml-bundle create
+				#aml-bundle 
+
+				argument.create_if_empty('method','')
+				argument.create_if_empty('mixin','')
+				argument.create_if_empty('partial','')
+				#ap argument.hash
+				name = {:directory => argument.read('name').downcase.gsub(' ','-'), :class => argument.read('name').gsub(' ','')}	
+				FileUtils.mkdir_p(File.join(name[:directory],'partial'))
+				%w"method.rb mixin.aml".each do |file|
+					File.new(File.join(name[:directory],"#{file}"), 'w')
+				end
+				mixins = "%!-- #{argument.read('name')} Mixin Definitions --%"
+				argument.read('mixin').split(' ').each do |mixin|
+					mixin = mixin.split(':')
+					mixin_name = mixin[0]
+					attributes = ""
+					if mixin.count > 1
+						mixin.shift
+						mixin.each do |attribute|
+							a = attribute.split('=')
+							attributes +="#{a[0]}='#{a[1]}',"
+						end
+						attributes = "(#{attributes[0..-2]})"
+					end
+					mixins += "\r\n%%#{mixin_name}#{attributes}{\r\n\t\r\n}"
+				end
+				File.open(File.join(name[:directory],'mixin.aml'), 'w'){|file|file.write(mixins)}
+				File.open(File.join(name[:directory],'method.rb'), 'w'){|file|file.write("class #{name[:class]}\r\n\tdef self.aml\r\n\t\t\r\n\tend\r\nend")}
+				argument.read('partial').split(' ').each do |partial|
+					File.new(File.join(name[:directory],'partial',"#{partial}.aml"),'w')
+				end
+			end
+		end
+
+	end
+end