aml 0.1.1.1 → 0.1.2

data/lib/aml/Line.rb

@@ -0,0 +1,80 @@
+# Convert a string input to a Hash output.
+class Line
+	# Create a new Line with a symbol type and regular expression.
+	def initialize(bundle, type, regex)
+		@line = {}
+		@line[:type] = type
+		@line[:regex] = regex
+		@line[:bundle] = bundle
+	end
+	# Return a Hash if the line match is successful, otherwise false.
+	def match?(string,number)
+		match = string.match(@line[:regex])
+		match ? process_match(match,number) : false
+	end
+	private
+	# Return a processed Hash based on the matches and convert keys to symbols.
+	def process_match(match,number)
+		line = Hash[match.names.zip(match.captures)]
+		line = Hash[line.map{|(k,v)| [k.to_sym,v]}]
+		line[:type] = @line[:type]
+		line[:index] = match[0].match(/^\t{0,}/).to_s.length
+		line[:number] = number
+		line[:name] = 'div' and line[:type] = :tag if line[:type] == :tag_shorthand
+		# attribute value to Hash
+		line[:attribute] = recursive_string_to_hash(line[:attribute]) if line.key? :attribute
+		# key values to String
+		%w[bundle class name text value id_first id_last reset].each do |key|
+			line[key.to_sym] = line[key.to_sym].to_s if line.key? key.to_sym
+		end
+		# key values to String.Strip!
+		%w[text].each do |key|
+			line[key.to_sym] = line[key.to_sym].strip! if line.key? key.to_sym
+		end
+		# bundle
+		line[:bundle] = @line[:bundle] if line.key? :bundle and line[:bundle].to_s.length == 0
+		if line[:type] == :mixin
+			line[:bundle] = 'core' and line[:name] = line[:name][1..-1]  if line[:name][0] == '.'
+		elsif line[:type] == :method
+			line[:bundle] = 'core' if line[:bundle] == false
+		end
+		# class
+		if line.key? :class
+			line[:class] = '.' + line[:class]
+			line[:attribute][:class] = line[:class].split('.').join(' ').strip!
+			line.delete(:class)
+		end
+		# close 
+		line[:close] = %w(tag self none)[line[:close].to_s.length].to_sym if line.key? :close
+		# id
+		if line.key? :id_first and line[:id_first].length > 0
+			line[:attribute][:id] = line[:id_first]
+		elsif line.key? :id_last and line[:id_last].length > 0
+			line[:attribute][:id] = line[:id_last]
+		end
+		line.delete(:id_first) if line.key? :id_first
+		line.delete(:id_last) if line.key? :id_last
+		# reset
+		line[:reset] = line[:reset].to_s.length == 0 ? false : true if line.key? :reset
+		# return sorted Hash
+		Hash[line.sort]
+	end
+	# Return the Hash equivalent of a given String (no evaluation).
+	def recursive_string_to_hash(string)
+		hash = {}
+		regex = /:(?<name>\w+)\s?=>\s?(?<hash>{(.+?)?}|(?<quote>'|")(?<value>.+?)??\k<quote>)/
+		names = regex.names
+		if string != nil
+			string.scan(regex){|match|
+				thisHash = Hash[names.zip(match)]
+				if thisHash["hash"].to_s[0] == "{"
+					hash[thisHash["name"].to_sym] = recursive_string_to_hash(thisHash["hash"])
+				else
+					hash[thisHash["name"].to_sym] = thisHash["value"].to_s.strip
+				end
+			}
+		end
+		# return sorted Hash
+		Hash[hash.sort]
+	end
+end

data/lib/aml/Parse.rb

@@ -0,0 +1,24 @@
+class Parse
+	require "aml/Line"
+	def initialize(bundle=false)
+		@line = []
+		@line << Line.new(bundle, :variable_definition, /^(\s{1,})?\@((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\s?(\=)\s?(?<value>.+)?$/)
+		@line << Line.new(bundle, :mixin, /^(\s{1,})?%\(((?<bundle>[\w|\-]+)\.)?(?<name>[^~][\w|\-]+)\)(\{(?<attribute>.+)\})?[^\{]?/)
+		@line << Line.new(bundle, :mixin_definition, /^%%(?<name>[\w|\-]+)(\((?<attribute>.+?)\))?{/)
+		@line << Line.new(bundle, :mixin_end, /^\}$/)
+		@line << Line.new(bundle, :partial, /^(\s{1,})?%\(\~((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)(\{(?<attribute>.+)\}[^\{]?)?$/)
+		@line << Line.new(bundle, :tag, /^(\s{1,})?(?<!%)%(?<close>\/{0,2})?(?<name>[\w|\-]+)(\#(?<id_first>[\w|\-]+))?(\.(?<class>[\w|\-|\.]+))?(\#(?<id_last>[\w|\-]+))?(?<reset>\*{1,})?(\{(?<attribute>.+)\})?(?<text>.+)?$/)
+		@line << Line.new(bundle, :tag_shorthand, /^(\s{1,})?(?=[#|\.|\/])(?<close>\/{0,2})?(\#(?<id_first>[\w|\-]+))?(\.(?<class>[\w|\-|\.]+))?(\#(?<id_last>[\w|\-]+))?(?<reset>\*{1,})?(\{(?<attribute>.+)\})?(?<text>.+)?$/)
+		@line << Line.new(bundle, :conditional, /^(\s{1,})?-\s?(?<name>if|loop|end)(\s(?<value>.+))?$/)
+		@line << Line.new(bundle, :empty, /^$/)
+		@line << Line.new(bundle, :eval, /^(\s{1,})?==(\s{1,})(?<value>.+)?/)
+		@line << Line.new(bundle, :string, /(\s{1,})?(?<value>.+)?/)
+	end
+	# Return the line as a Hash.
+	def line(string,number)
+		@line.each do |type|
+			line = type.match?(string,number)
+			return line if line
+		end
+	end
+end

data/lib/aml/Prepare.rb

@@ -0,0 +1,59 @@
+class Prepare
+	require "aml/Cluster"
+	def initialize(file)
+		@log = []
+		@cluster = false
+		@file = []
+		@watch = []
+		# Load Core Bundle
+		path = File.join(File.dirname(File.expand_path(__FILE__)),'core')
+		add_file(File.join(path,'mixin.aml'),'mixin', 'core')
+		add_watch(File.join(path,'method.rb'), 'method', 'core')
+		# Load Local Bundles
+		bundles = Definition.new(file, false)
+		bundles.self[:hash].reject{|k|k[:bundle] == false or k[:bundle] == nil}.each do |bundle|
+			if @file.select{|k|k[:bundle] == bundle[:bundle]}.count == 0
+				path = File.join(File.dirname(file), bundle[:bundle])
+				add_file(File.join(path,'mixin.aml'), 'mixin', bundle[:bundle])
+				add_watch(File.join(path,'method.rb'), 'method', bundle[:bundle])
+				# Load Only Required Partials
+				bundles.self[:hash].reject{|k|k[:bundle] != bundle[:bundle]}.reject{|k|k[:type] != :partial}.each do |partial|
+					add_file(File.join(path,'partial',partial[:name]+'.aml'), 'partial', bundle[:bundle], bundle[:name])
+				end
+			end
+		end
+		# Load Local File Mixin & Method
+		path = File.join(File.dirname(file))
+		add_file(File.join(path,'mixin.aml'), 'mixin')
+		add_watch(File.join(path,'method.rb'), 'method')
+		# Load Only Requird Local Partials
+		bundles.self[:hash].select{|k|k[:type] == :partial and k[:bundle] == false}.each do |bundle|
+			add_file(File.join(path,'partial',bundle[:name]+'.aml'), 'partial', bundle[:bundle], bundle[:name])
+		end
+		# Load Local File
+		add_file(file,'base')
+		
+		@watch.concat(@file)
+		process
+	end
+	def add_file(file, type, bundle=false, partial=false)
+		@file << {:file=>file, :type=> type, :bundle=>bundle, :partial=>partial}
+	end
+	def add_watch(file, type, bundle=false)
+		@watch << {:file=>file, :bundle=>bundle}
+	end
+	def process
+		@cluster = Cluster.new(@file)
+		@cluster.process
+		@log = cluster.log
+	end
+	def log
+		@log
+	end
+	def cluster
+		@cluster
+	end
+	def watch
+		@watch
+	end
+end

data/lib/aml/core/method.rb

@@ -1,13 +1,23 @@
 class Core
 
 	@words = %w[a ac accumsan adipiscing aenean aliquam aliquet amet ante arcu at auctor augue bibendum blandit commodo condimentum congue consectetur consequat convallis cras curabitur cursus dapibus diam dictum dictumst dignissim dis dolor donec dui duis egestas eget eleifend elementum elit enim erat eros est et etiam eu euismod facilisi facilisis fames faucibus felis fermentum feugiat fringilla fusce gravida habitasse hac hendrerit iaculis id imperdiet in integer interdum ipsum justo lacinia lacus laoreet lectus leo libero ligula lobortis lorem luctus maecenas magna magnis malesuada massa mattis mauris metus mi molestie mollis montes morbi mus nam nascetur natoque nec neque nibh nisi nisl non nulla nullam nunc odio orci ornare parturient pellentesque penatibus pharetra phasellus placerat platea porta porttitor posuere potenti praesent pretium primis proin pulvinar purus quam quis quisque rhoncus ridiculus risus rutrum sagittis sapien scelerisque sed sem semper sit sociis sodales sollicitudin suscipit suspendisse tellus tempor tempus tincidunt tortor tristique turpis ullamcorper ultrices ultricies urna ut varius vehicula vel velit venenatis vestibulum vitae vivamus viverra volutpat vulputate]
-	
+
 	def self.date(index=0, a={}, d={:format=>'%Y-%m-%d %H:%M:%S'})
 		a = d.merge(a)
 		time = Time.new
 		return time.strftime(a[:format])
 	end
-	
+
+	def self.copyright(index=0, a={}, d={:name=>false})
+		a = d.merge(a)
+		return '© ' + self.year + ' ' + a[:name]
+	end
+
+	def self.alphanumeric(index=0, a={}, d={:string=>nil})
+		a = d.merge(a)
+		return a[:string].downcase.gsub(/[^a-zA-Z0-9]/,'-')
+	end
+
 	def self.year(index=0, a={})
 		return self.date(index,{:format=>'%Y'})
 	end
@@ -21,6 +31,11 @@ class Core
 			string = self._random_paragraph(a[:number])
 		elsif a[:type] == 'sentence'
 			string = self._random_sentence(a[:number])
+		elsif a[:type] == 'title'
+			for i in 1..rand(a[:number]-1)+1
+				string += self._random_word(a[:capitalize]) + " "
+			end
+			string.strip!
 		elsif a[:type] == 'word'
 			string = self._random_word(a[:capitalize])
 		elsif a[:type] == 'name'

data/lib/aml/core/mixin.aml

@@ -7,7 +7,7 @@
 %%html5-{
 	<!DOCTYPE html>
 }
-%%html5{
+%%html5(:this=>'this',:that=>'that'){
 	%(.html5-)
 	%html
 }

metadata

@@ -1,38 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: aml
 version: !ruby/object:Gem::Version
-  version: 0.1.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Daniel Esquivias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-23 00:00:00.000000000 Z
+date: 2014-06-08 00:00:00.000000000 Z
 dependencies: []
 description: Abstract Markup Language is a robust and feature rich markup language
   designed to avoid repetition and promote clear, well-indented markup.
 email: daniel@abstractmarkup.com
 executables:
 - aml
-- aml-bundle
 extensions: []
 extra_rdoc_files: []
 files:
 - bin/aml
-- bin/aml-bundle
-- lib/aml/argument.rb
-- lib/aml/compile.rb
+- lib/aml/Argument.rb
+- lib/aml/Build.rb
+- lib/aml/Cluster.rb
+- lib/aml/Compile.rb
 - lib/aml/core/method.rb
 - lib/aml/core/mixin.aml
-- lib/aml/definition.rb
-- lib/aml/error.rb
-- lib/aml/line_type.rb
-- lib/aml/make.rb
-- lib/aml/parse.rb
-- lib/aml/requirement.rb
-- lib/aml/watch.rb
-- lib/aml-bundle.rb
+- lib/aml/Definition.rb
+- lib/aml/Line.rb
+- lib/aml/Parse.rb
+- lib/aml/Prepare.rb
 - lib/aml.rb
 homepage: https://abstractmarkup.com
 licenses:

data/bin/aml-bundle

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

data/lib/aml-bundle.rb

@@ -1,52 +0,0 @@
-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('action','The required --generate argument has not been defined.')
-			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')
-
-				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

data/lib/aml/argument.rb

@@ -1,80 +0,0 @@
-class Argument
-	
-	@@argumental = {}
-	@@required = {}
-
-	@@error
-
-	def initialize(arguments,error)
-		@@error = error
-		parse(arguments)
-	end
-	
-	def parse(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 clear_required
-		@@required = {}
-	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 defined(name)
-		@@argumental.select{|k,v| k.to_s == name}.count > 0
-	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/compile.rb

@@ -1,325 +0,0 @@
-class Compile
-
-	@@structure = []
-	@@selfClosing = []
-
-	def initialize(parse,argument,definition,error)
-		@@selfClosing = argument.read('selfClosing').split(',')
-		error.compile(parse,definition,error)
-		if(error.count == 0)
-			prepare_line_variable(parse.file[:line],definition)
-			lines = []
-			parse.file[:line].each do |line|
-				lines << post_prepare_line_variable(line)
-			end
-
-			parse.file[:line] = lines
-
-			prepare_mixin_structure(parse.file[:line],definition)
-			prepare_partial_structure(parse.file[:line],definition)
-			prepare_method_structure(parse.file[:line],definition)
-			
-			prepare_string_line_merge(parse.file[:line])
-
-			structure = prepare_structure(parse.file[:line])
-
-			recursive_merge_lines(structure)
-
-			structure.each do |group|
-				recursive_close(group,0,definition,0)
-			end
-
-			make = Make.new(@@structure)
-		end
-	end
-
-	def recursive_merge_lines(struct,count=0)
-	    struct.each_with_index do |group,struct_index|
-	        group.each_with_index do |line,gindex|
-	            if line.first == :line
-	                if line.last[:type] == :string and line.last[:merge]
-	                    next_line = struct[struct_index+1].first
-	                    if next_line.first == :line and next_line.last[:type] == :string
-	                        line.last[:value] += next_line.last[:value]
-	                        line.last[:merge] = next_line.last[:merge]
-	                        line.last[:merge] = struct_index+1 == struct.count ? false : line.last[:merge]
-	                        struct.delete_at struct_index+1
-	                    else
-	                       line.last[:merge] = false 
-	                    end
-	                    count +=1 if line.last[:merge]
-	                end
-	            else
-	                recursive_merge_lines(line.last)
-	            end
-	        end
-	    end
-	    recursive_merge_lines(struct) if count > 0
-	end
-
-	def prepare_string_line_merge(lines)
-		regex = /\%\+\+$/
-		lines.each_with_index do |line,index|
-			if(line[:type] == :string)
-				line[:merge] = line[:value].to_s.match(regex) != nil
-				line[:value] = line[:value].to_s.gsub(regex,'') if line[:merge]
-			end
-		end
-		lines
-	end
-
-	def prepare_method_structure(lines,definition)
-		lines.each_with_index do |line,index|
-			if line[:type] == :method
-				line[:type] = :string
-				bundle = line[:bundle]
-				bundle = "Core" if bundle == 'core'
-				line[:value] = AbstractMarkupLanguage::Base.const_get(bundle).method(line[:name]).call(line[:index],line[:attributes]) + line[:value]
-			end
-		end
-		lines
-	end
-
-	def prepare_partial_structure(lines,definition)
-		definition_partial = definition.variables.clone
-		bundle = nil
-		lines.each_with_index do |line,index|
-			if line[:type] == :partial
-				lines.delete_at index
-				bundle = line[:bundle]
-				directory = 'partial'
-				directory = File.join(line[:bundle],directory) if line[:bundle]
-				directory = File.join(AbstractMarkupLanguage::Base.basePath, directory)
-				variable = {}
-				definition.variables[line[:bundle]].each do |var,val|
-					value = val.count > 1 ? val.to_a.last[1] : val[1]
-					value = line[:attributes][var.to_sym] if line[:attributes].has_key?(var.to_sym)
-					variable[var] = {1 => value} if value != nil
-				end if definition.variables[line[:bundle]] != nil
-				partial = Parse.new(File.join(directory),"#{line[:name]}.aml",true, line[:bundle])
-				partial.file[:line].each_with_index do |pline,pindex|
-					pline[:index] += line[:index]
-					pline[:number] = line[:number]
-					lines.insert(index+pindex,pline)
-				end
-				definition_partial[line[:bundle]] = definition_partial[line[:bundle]].merge(variable) if  definition_partial[line[:bundle]] != nil
-				vars = DefinitionVariable.new(definition_partial)
-				prepare_line_variable(lines,vars)
-				break
-			end
-		end
-		prepare_partial_structure(lines,definition) if(lines.select{|k|k[:type]==:partial}).count > 0
-		prepare_line_variable(lines,definition)
-		prepare_mixin_structure(lines,definition)
-		lines
-	end
-
-	def prepare_line_variable(lines,definition)
-		regex = /\@\(((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)/
-		if lines.kind_of?(Array)
-			lines.each do |line|
-				line = line_variable_replace(line,definition)
-			end
-		else
-			lines = line_variable_replace(lines,definition)
-		end
-		check = 0
-		if lines.kind_of?(Array)
-			check_text = lines.select{|k| k[:text].to_s.match(regex)}
-			check_value = lines.select{|k| k[:value].to_s.match(regex)}
-			check = check_text.count+check_value.count
-		end
-		prepare_line_variable(lines,definition) if check > 0
-		lines
-	end
-
-	def post_prepare_line_variable(line)
-		types	=	{
-			:method			=>	LineType.new(/^(\s{1,})?::((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)(\{(?<attributes>.+)\})?(?<value>.+)?/),
-			:mixin			=>	LineType.new(/^(\s{1,})?%\(((?<bundle>[\w|\-]+)\.)?(?<name>[^~][\w|\-]+)\)(\{(?<attributes>.+)\})?[^\{]?/),
-			:partial		=>	LineType.new(/^(\s{1,})?%\(\~((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)(\{(?<attributes>.+)\}[^\{]?)?$/),
-			:tag			=>	LineType.new(/^(\s{1,})?(?<!%)%(?<close>\/{0,2})?(?<name>[\w|\-]+)(?<tab_reset>\*{1,})?(\#(?<id_first>(\@\(([\w|-]+\.)?)?[\w|\-]+(\))?))?(?<class>(\.[\w|\-]+)?{1,})?(\#(?<id_last>[\w|\-]+))?(\{(?<attributes>.+)\})?(?<text>.+)?/)
-		}
-		if line[:type] == :string
-			types.each do |type, line_type|
-				if match = line_type.match?(line[:value])
-					struct = Hash[match.names.zip(match.captures)]
-					struct = Hash[struct.map{|(k,v)| [k.to_sym,v]}]
-					struct[:index] = line[:index]
-					struct[:number] = line[:number]
-					struct[:type] = type
-					match.names.each do |name|
-						struct[name.to_sym] = line_type.send(name.to_s, match)
-					end
-					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
-					break
-				end
-			end
-		end
-		line
-	end
-
-	def line_variable_replace(line,definition)
-		regex = /\@\(((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)/
-		%w"text value".each do |key|
-			key = key.to_sym
-			if line.has_key?(key)
-				line[key] = line[key].to_s.gsub(regex){definition.variable($2,line[:number],$1.to_s.length > 0 ? $1 : false).to_s} if line[key].to_s.length > 0
-			end
-		end
-		if line.has_key?(:attributes) and line[:attributes].count > 0
-			line[:attributes].each do |k,v|
-				if v.is_a?(Hash) == false
-					line[:attributes][k] = line[:attributes][k].to_s.gsub(regex){definition.variable($2,line[:number],$1.to_s.length > 0 ? $1 : false).to_s} if v.to_s.length > 0
-				end
-			end
-		end
-	end
-
-	def line_attribute_replace(line,default_attributes,mixin_attributes)
-		regex = /@\(\:(?<name>[\w|\-]+)\)/
-		mixin_attributes.merge!(default_attributes){|key, mixin, default| mixin}
-		if mixin_attributes.length > 0
-			%w"text value".each do |key|
-				line[key.to_sym] = line[key.to_sym].to_s.gsub(regex){mixin_attributes[$1.to_sym]} if line.has_key?(key.to_sym)
-			end
-			if(line.has_key?(:attributes))
-				attributes = line[:attributes].clone
-				attributes.each do |k,v|
-					attributes[k] = v.to_s.gsub(regex){mixin_attributes[$1.to_sym]}
-				end
-				line[:attributes] = attributes
-			end
-		end
-		line
-	end
-
-	def prepare_mixin_structure(lines,definition)
-		lines.each_with_index do |line,index|
-			if line[:type] == :mixin
-				lines.delete_at index
-				mixin = definition.mixin(line[:name],line[:bundle])
-				if(mixin.is_a?(Hash))
-					mixin = mixin.clone
-					mixin[:structure].each_with_index do |mline,mindex|
-						mixin_line = mline.clone
-						mixin_line[:index] += line[:index]
-						mixin_line[:number] = line[:number]
-						line_attribute_replace(mixin_line,mixin[:attribute],line[:attributes])
-						lines.insert(index+mindex,mixin_line)
-					end
-				end
-				break
-			end
-		end
-		prepare_mixin_structure(lines,definition) if(lines.select{|k|k[:type]==:mixin}).count > 0
-		prepare_line_variable(lines,definition)
-		lines
-	end
-
-	def prepare_structure(struct,index=0,pstruct={:line=>false,:children=>[]})
-		parent_tags = struct.each_index.select{|i| struct[i][:index] == index}.compact
-		parent_struct = []
-		parent_tags.each_with_index do |struct_index,index|
-			last_struct_index = parent_tags.count > index+1 ? parent_tags[index+1]-1 : parent_tags[index]
-			last_struct_index = struct.count if(parent_tags.count == index+1)
-			parent_struct << struct[struct_index..last_struct_index]
-		end
-		parent_struct.each do |parent_structure|
-			index_struct = {}
-			index_struct[:line] = parent_structure[0]
-			c = prepare_structure(parent_structure,index+1)
-			index_struct[:children] = c if c.count > 0
-			pstruct[:children] << index_struct 
-		end
-		pstruct[:children]
-	end
-
-	def recursive_close(struct,index=0,definition,index_reset)
-		next_index	=	struct.key?(:line) ? index+1 : index
-		tab_index	=	"\t" * (index-index_reset)
-		opening_tag_attributes = ""
-		opening_tag = ""
-		closing_tag = ""
-		
-		#STRING
-		if(struct[:line][:type]==:string)
-			opening_tag = struct[:line][:value]
-		end
-
-		#TAG
-		if(struct[:line][:type]==:tag)
-
-			struct[:line][:close] = 'self' if @@selfClosing.include? struct[:line][:name]
-
-			opening_tag_attributes = tag_line_attributes(struct[:line],"",definition)
-			opening_tag	=	"<#{struct[:line][:name]}#{opening_tag_attributes}>"
-			closing_tag =	"</#{struct[:line][:name]}>"
-			if struct.key?(:line)
-				if struct[:line][:close] == 'self'
-					opening_tag	=	"<#{struct[:line][:name]}#{opening_tag_attributes} />"
-					closing_tag	=	""
-				end
-				if struct[:line][:close] == 'none'
-					closing_tag	=	""
-				end
-			end
-		end
-		tag_text = struct[:line][:text]
-		if struct.key?(:children)
-			new_line = "\r\n"
-			
-			#testing * aka tab_reset
-			index_reset = struct[:line][:index]+1 if struct[:line][:tab_reset].to_s.length > 0
-
-			tag_text = "#{new_line}#{tab_index}\t#{tag_text}" if tag_text.to_s.length > 0
-
-			@@structure << "#{tab_index}#{opening_tag}#{tag_text}" if struct.key?(:line)
-			struct[:children].each do |struct_children|
-				recursive_close(struct_children,next_index,definition,index_reset)
-			end
-			@@structure << "#{tab_index}#{closing_tag}" if struct.key?(:line)
-		else
-			@@structure << "#{tab_index}#{opening_tag}#{tag_text}#{closing_tag}"
-		end
-
-	end
-
-	def tag_line_attributes(line,base="",definition)
-		if line[:type] == :tag
-			line[:attributes][:id] = line[:id] if line[:id].to_s.length > 0 and line[:attributes][:id].to_s.length == 0
-			line[:attributes][:class] = line[:class] if line[:class].to_s.length > 0 and line[:attributes][:class].to_s.length == 0
-			attributes = hash_to_attribute_build(line[:attributes],"",definition,line)
-			attributes = " #{attributes}" if(attributes.length > 0)
-		end
-	end
-
-	def hash_to_attribute_build(hash,base="",definition,line)
-		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}-",definition,line)} "
-			else
-				#if key == :id
-				#	regex = /\@\(((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)/
-				#	value = value.to_s.gsub(regex){definition.variable($2,line[:number],$1.to_s.length > 0 ? $1 : false).to_s} if value.to_s.length > 0
-				#end
-				string << "#{base}#{key}=\"#{value}\" "
-			end
-		end
-		string.strip
-	end
-end