aml 0.1.1.1 → 0.1.2

data/lib/aml/definition.rb

@@ -1,71 +0,0 @@
-class DefinitionVariable
-	@variable = {}
-	def initialize(variable)
-		@variable = 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
-end
-
-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 or k[:type] == :mixin}.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

@@ -1,97 +0,0 @@
-class Error
-	@errors
-	@warnings
-	def initialize
-		@errors = []
-		@warnings = []
-	end
-	def warnings
-		@warnings
-	end
-	def log(bundle,partial,file,line,message,warning=false)
-		file = "partial/#{file}" if partial != false
-		file = "#{bundle}/#{file}" if bundle != false
-		line = line ? "::#{line}" : nil
-		text = "#{file}#{line} #{message}"
-		if warning
-			@warnings << text
-		else
-			@errors << text
-		end
-	end
-	def count
-		@errors.count
-	end
-	def log_delete
-		begin
-			File.delete(File.join(AbstractMarkupLanguage::Base.basePath,'aml-log'))
-		rescue Exception => e
-		end
-	end
-	def log_create
-		error_output = ""
-		@errors.each do |error|
-			error_output += "Error: #{error}\r\n"
-		end
-		@warnings.each do |warning|
-			error_output += "Warning: #{warning}\r\n"
-		end
-		File.write(File.join(AbstractMarkupLanguage::Base.basePath,'aml-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

@@ -1,57 +0,0 @@
-LineType = Struct.new(:regex) do
-	def match?(string)
-		string.match(regex)
-	end
-	def attributes(match)
-		begin
-			stringHashToHash(match[:attributes])
-		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
-	def tab_reset(match)
-		match[:tab_reset].to_s
-	end
-	def stringHashToHash(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] = stringHashToHash(thisHash["hash"])
-				else
-					hash[thisHash["name"].to_sym] = thisHash["value"].to_s
-				end
-			}
-		end
-		hash
-	end
-end

data/lib/aml/make.rb

@@ -1,12 +0,0 @@
-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) ? $/ : ""
-				file.write(line+new_line) if line.strip.length > 0
-			end
-		}
-	end
-end

data/lib/aml/parse.rb

@@ -1,81 +0,0 @@
-class Parse
-	def file
-		return @file
-	end
-	def watch
-		return @watch
-	end
-	def mixin
-		return @mixin
-	end
-	def initialize(path, file, partial=false, bundle=false)
-		@path	=	path
-		@regex	=	{
-			:attribute		=>	/@\(\:(?<name>[\w|\-]+)\)/,
-			:comment		=>	/%!--[^%]*--%$/,
-			:variable		=>	/\@\(((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)/
-		}
-		@types	=	{
-			:method			=>	LineType.new(/^(\s{1,})?::((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)(\{(?<attributes>.+)\})?(?<value>.+)?/),
-			: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|\-]+)(?<tab_reset>\*{1,})?(\#(?<id_first>(\@\(([\w|-]+\.)?)?[\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>.+)?/)
-		}
-		@file	=	{}
-		@watch	=	[]
-		@mixin 	=	[]
-		read(file, partial, bundle)
-	end
-	def read(file, partial, bundle)
-		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
-					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[:bundle] = bundle if bundle != false
-					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
-			end
-		end
-		@file = {:name => file, :line => line_struct}
-		@watch << {:file => file, :bundle => false, :partial => false}
-		partial_watch(line_struct)
-		mixin_watch(line_struct)
-	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
-	end
-	def mixin_watch(struct)
-		struct.reject{|k,v| k[:type] != :mixin}.each do |partial|
-			@mixin << {:file => "mixin.aml", :bundle=> partial[:bundle], :partial => false} if partial[:bundle] != 'core'
-		end
-	end
-end

data/lib/aml/requirement.rb

@@ -1,9 +0,0 @@
-#require "awesome_print"
-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,38 +0,0 @@
-class Watch
-	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 if File.exists?(filename)
-		end
-		@filenames = filenames
-		watch
-	end
-	def watch(sleep=1)
-		loop do
-			begin
-				Kernel.sleep sleep until file_updated?
-				rescue SystemExit,Interrupt
-				puts ""
-				Kernel.exit!
-			end
-		end
-	end
-	def file_updated?
-		@filenames.each do |filename|
-			if File.exists?(filename)
-				mtime = File.stat(filename).mtime
-				updated = @last_mtimes[filename] < mtime
-				@last_mtimes[filename] = mtime
-				if(updated)
-					exec("aml #{@arguments} --aml-watch-instance #{@instance}")
-					Kernel.exit!
-					return true
-				end
-			end
-		end
-		return false
-	end
-end