aml 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62586a90cf259bfb9db8e6144d6b617eac6f62f7
-  data.tar.gz: 83cd34500258139d04cfd6d91a484ff53aa62fcc
+  metadata.gz: b0cdc40b541bc19e5680c9216bc712639b954f98
+  data.tar.gz: dc1ae55d6d5c42dd4811a63689da7033436f2568
 SHA512:
-  metadata.gz: f6a5e3848de3b9e91245fcfeb9d74546f38816e285d794601d59461f9dda536ae8ff427c6b0bea8bfa4001657ba8982890808f50786d5a2cfa34942b699dd544
-  data.tar.gz: 4ec08e0e48c78777aeda9ffe8563d448e9ee42988e41be19149f87fa5a917a107c399108a7eea97c89665de1562b1e4513210eceafd06b20f9264465496b3516
+  metadata.gz: 472033267cf83259a6f37ae2041e06dfab735961148a48be84b2da66b876e2e193514d1f69887e25a0d8bc58a3f5c51cbd5206addf0ca7314f014a3a8e9e4929
+  data.tar.gz: 3c62a5f13935b8fc6c9e52a40374671693b4c272bd31d4a8ade79b49a8176a1648b0a9b2201b497b41fd6885ecc0fc7d27695cf5451d91a3e6b69fde8762ad32

data/bin/aml

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

data/bin/aml-bundle

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

data/lib/aml/argument.rb

@@ -2,15 +2,22 @@ class Argument
 	
 	@@argumental = {}
 	@@required = {}
+
+	@@error
+
+	def initialize(arguments,error)
+		@@error = error
+		parse(arguments)
+	end
 	
-	def initialize(arguments)
+	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
@@ -33,6 +40,10 @@ class Argument
 		end
 		message
 	end
+
+	def clear_required
+		@@required = {}
+	end
 	
 	def create(name,value)
 		@@argumental[name.to_sym] = value.strip if(value.length > 0)

data/lib/aml/compile.rb

@@ -0,0 +1,163 @@
+class Compile
+
+	@@structure = []
+	
+	def initialize(parse,argument,definition,error)
+		error.compile(parse,definition,error)
+		if(error.count == 0)
+			prepare_line_variable(parse.file[:line],definition)
+			prepare_mixin_structure(parse.file[:line],definition)
+			structure = prepare_structure(parse.file[:line])
+			structure.each do |group|
+				recursive_close(group)
+			end
+			make = Make.new(@@structure)
+		end
+	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 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|
+				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
+		line
+	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
+			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
+		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)
+		next_index	=	struct.key?(:line) ? index+1 : index
+		tab_index	=	"\t" * index
+		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)
+			opening_tag_attributes = tag_line_attributes(struct[:line])
+			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)
+			tag_text = "\r\n#{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)
+			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)
+		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 = ""
+			line[:attributes].each do |attribute,value|
+				attributes += " #{attribute.to_s}=\"#{value.to_s}\"" if(value.to_s.length) > 0 and value.to_s != 'nil'
+				attributes += " #{attribute.to_s}" if(value.to_s) == "nil"
+			end
+			attributes
+		end
+	end
+end

data/lib/aml/core/method.rb

@@ -0,0 +1,19 @@
+class Core
+	def self.loop(index=0, a={})
+		return "loop"
+	end
+	def self.date(index=0, a={:format=>'%Y-%m-%d %H:%M:%S'})
+		time = Time.new
+		return time.strftime(a[:format])
+	end
+	def self.ipsum(index=0, a={})
+		return "%p lorem ipsum sit amet dolor"
+	end
+	def self.random(index=0, a={})
+		return "random"
+	end
+	def self.copyright(index=0, a={})
+		time = Time.new
+		return "%p © #{time.year}"
+	end
+end

data/lib/aml/core/mixin.aml

@@ -0,0 +1,52 @@
+%!-- VARIABLES --%
+
+@aml = Abstract Markup Language
+
+%!-- DOCTYPES ---%
+
+%%html5{
+	<!DOCTYPE html>
+	%html
+}
+%%html401s{
+	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+	%html
+}
+%%html401t{
+	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+	%html
+}
+%%html401f{
+	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
+	%html
+}
+%%xhtml1s{
+	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+	%html
+}
+%%xhtml1t{
+	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+}
+%%xhtml1f{
+	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+	%html
+}
+%%xhtml11{
+	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+	%html
+}
+
+
+%!-- HELPERS ---%
+
+%%stylesheet(:href=>''){
+	%/link{:href=>'@(:href).css',:rel=>'stylesheet'}
+}
+
+%%javascript(:href=>''){
+	%/script{:href=>'@(:href).js',:type=>'text/javascript'}
+}
+
+%%favicon(:href=>''){
+	%/link{:rel=>'icon',:type=>'image/png',:href=>'@(:href)'}
+}

data/lib/aml/definition.rb

@@ -0,0 +1,61 @@
+class Definition
+	def initialize(parse,scope=false,add_bundle=true,add_mixin=true,add_variable=true)
+		@bundle = {}
+		@mixin = {}
+		@variable = {}
+		add(parse,scope,add_bundle,add_mixin,add_variable)
+	end
+	def add(parse,scope=false,add_bundle=true,add_mixin=true,add_variable=true)
+		#define bundles
+		parse[:line].select{|k,v| k[:type] == :method or k[:type] == :partial}.each do |bundle|
+			@bundle[bundle[:bundle]] = camelCase(bundle[:bundle]) if @bundle.has_key?(bundle[:bundle]) == false and bundle[:bundle] != false
+		end if add_bundle
+		#define mixins
+		mixin_def = parse[:line].reject{|k,v| k[:type] != :mixin_def}
+		mixin_end = parse[:line].reject{|k,v| k[:type] != :mixin_end}
+		if(mixin_def.count == mixin_end.count)
+			mixin_def.each_with_index do |mixin,index|
+				mixin[:bundle] = scope if scope
+				@mixin[mixin[:bundle]] = {} if @mixin.has_key?(mixin[:bundle]) == false
+				@mixin[mixin[:bundle]][mixin[:name]] = {} if @mixin[mixin[:bundle]].has_key?(mixin[:name]) == false
+				@mixin[mixin[:bundle]][mixin[:name]] = {
+					:attribute => mixin[:attributes],
+					:structure => parse[:line].reject{|k,v| k[:number].between?(mixin[:number]+1,mixin_end[index][:number]-1) == false}
+				}
+				@mixin[mixin[:bundle]][mixin[:name]][:structure].each do |line|
+					line[:index]-=1
+				end
+				parse[:line] = parse[:line].reject{|k,v| k[:number].between?(mixin[:number],mixin_end[index][:number])}
+			end
+		end if add_mixin
+		#define variables
+		variable = parse[:line].reject{|k,v| k[:type] != :variable_def}
+		variable.each do |var|
+			var[:bundle] = scope if scope
+			@variable[var[:bundle]] = {} if @variable.has_key?(var[:bundle]) == false
+			@variable[var[:bundle]][var[:name]] = {} if @variable[var[:bundle]].has_key?(var[:name]) == false
+			@variable[var[:bundle]][var[:name]][var[:number]] = var[:value]
+		end if add_variable
+	end
+	def camelCase(value)
+		value.split('-').each{|i|i.capitalize!}.join if value != false
+	end
+	def bundles
+		@bundle
+	end
+	def variables
+		@variable
+	end
+	def variable(name,line,bundle=false)
+		@variable[bundle].select{|variable| variable == name}.first[1].select{|line_number,value| line_number <= line}.values.last if (@variable.has_key?(bundle) and @variable[bundle].has_key?(name))
+	end
+	def mixins
+		@mixin
+	end
+	def mixins_of(bundle=false)
+		@mixin[bundle]
+	end
+	def mixin(name,bundle=false)
+		@mixin[bundle].select{|mixin|mixin==name}.first[1] if(@mixin.has_key?(bundle) and @mixin[bundle].has_key?(name))
+	end
+end

data/lib/aml/error.rb

@@ -0,0 +1,84 @@
+class Error
+	@errors
+	def initialize
+		@errors = []
+	end
+	def log(bundle,partial,file,line,message)
+		file = "partial/#{file}" if partial != false
+		file = "#{bundle}/#{file}" if bundle != false
+		line = line ? "::#{line}" : nil
+		@errors << "#{file}#{line} #{message}"
+	end
+	def count
+		@errors.count
+	end
+	def log_delete
+		begin
+			File.delete(File.join(AbstractMarkupLanguage::Base.basePath,'error.log'))
+		rescue Exception => e
+		end
+	end
+	def log_create
+		error_output = ""
+		@errors.each do |error|
+			error_output += "#{error}\r\n"
+		end
+		File.write(File.join(AbstractMarkupLanguage::Base.basePath,'error.log'),error_output)
+	end
+	def output
+		@errors.each do |error|
+			error
+		end
+	end
+	def match
+		/\((\w+)\)\:(?<line>\d+)\:(\s{1,})?(?<message>.+)/
+	end
+	def compile(parse,definition,error)
+		error.syntax(parse,false,false,error)
+		#Check Tag, Partial, Mixin Call, and Method Call Attributes for Errors
+		parse.watch.each do |file|
+			if file[:partial]
+				file_path = File.join(AbstractMarkupLanguage::Base.basePath,'partial')
+				file_path = File.join(AbstractMarkupLanguage::Base.basePath,file[:bundle],'partial') if file[:bundle]
+				partial_parse = Parse.new(file_path,file[:file])
+				error.syntax(partial_parse,file[:bundle],file[:partial],error)
+			end
+		end
+		#Check Mixin Definitions for Errors
+		definition.mixins.each do |bundle,mixins|
+			if(bundle != false and bundle != 'core')
+				file_path = File.join(AbstractMarkupLanguage::Base.basePath,bundle)
+				mixin_parse = Parse.new(file_path,'mixin.aml')
+				error.syntax(mixin_parse,bundle,false,error)
+			end
+		end
+	end
+	def syntax(parse,bundle=false,partial=false,error)
+		parse.file[:line].each do |line|
+			if(line[:attributes] && line[:attributes][:abstract_markup_language_exception] or partial && line[:type] == :mixin_def)
+				#Mixin definition in partials is not possible...
+				if line[:type] == :mixin_def and partial
+					file_to_define = bundle ? "#{bundle}/minxin.aml" : AbstractMarkupLanguage::Base.watchFile
+					error.log(bundle,partial,parse.file[:name],line[:number],"mixin must be defined in #{file_to_define}; #{line[:name]} cannot be defined in a partial")
+				else
+					line[:type] = "mixin definition" if line[:type] == :mixin_def
+					error.log(bundle,partial,parse.file[:name],line[:number],"attribute syntax error on #{line[:name]} #{line[:type]}")	
+				end
+			end
+			if line[:type] == :method
+				begin
+					#ap AbstractMarkupLanguage::Base.const_get(definition.camelCase(line[:bundle])).method(line[:name]).call()
+				rescue Exception => e
+					message = "#{line[:name]} method undefined in #{line[:bundle]} bundle"
+					if !AbstractMarkupLanguage::Base.constants.include? definition.camelCase(line[:bundle]).to_sym
+						message = "#{line[:bundle]} bundle undefined"
+					end
+					error.log(bundle,partial,parse.file[:name],line[:number],message)
+					false
+				end
+				#.method(line[:name]).call()
+				#ap Base.const_get(line[:bundle]).method(line[:name]).call()
+			end
+		end
+	end
+end

data/lib/aml/line_type.rb

@@ -0,0 +1,38 @@
+LineType = Struct.new(:regex) do
+	def match?(string)
+		string.match(regex)
+	end
+	def attributes(match)
+		begin
+			eval("{#{match[:attributes].to_s}}")
+		rescue Exception => e
+			{:abstract_markup_language_exception=>true}
+		end
+	end
+	def bundle(match)
+		match[:bundle].to_s
+	end
+	def class(match)
+		match[:class].to_s.split('.').join(' ').strip!
+	end
+	def name(match)
+		match[:name].to_s
+	end
+	def text(match)
+		match[:text].to_s.strip!
+	end
+	def value(match)
+		match[:value].to_s
+	end
+	def id_first(match)
+		match[:id_first].to_s
+	end
+	def id_last(match)
+		match[:id_last].to_s
+	end
+	def close(match)
+		# => </tag> /self> >
+		type = %w(tag self none)
+		type[match[:close].to_s.length]
+	end
+end

data/lib/aml/make.rb

@@ -0,0 +1,12 @@
+class Make
+	def initialize(structure)
+		makeFile = File.join(AbstractMarkupLanguage::Base.basePath,AbstractMarkupLanguage::Base.makeFile)
+		File.open(makeFile, 'w'){|file|
+			struct_count = structure.count-1
+			structure.each_with_index do |line,index|
+				new_line = (index < struct_count) ? "\r\n" : ""
+				file.write(line+new_line) if line.strip.length > 0
+			end
+		}
+	end
+end