aml 0.1.1.1 → 0.1.2

data/lib/aml/Cluster.rb

@@ -0,0 +1,201 @@
+# Cluster will have access to all variable and mixin definitions.
+class Cluster
+	require "aml/Definition"
+	def initialize(files)
+		@log = []
+		@definition = []
+		@cluster = {
+			:variables => {},
+			:mixins => {}
+		}
+		files.each do |file|
+			@definition << Definition.new(file[:file], file[:type], file[:bundle])
+		end
+	end
+	def process
+		@definition.each do |definition|
+			definition.log.each do |log|
+				@log << log
+			end
+			process_variable_definition(definition)
+			process_mixin_definition(definition)
+		end
+	end
+	def post_process
+		definition.each do |definition|
+			process_conditional(definition)
+		end
+	end
+	def log
+		@log
+	end
+	def variables
+		@cluster[:variables]
+	end
+	def mixins
+		@cluster[:mixins]
+	end
+	def definition
+		@definition
+	end
+	private
+	# Process Variable Definition (Cluster)
+	def process_variable_definition(definition)
+		definition.self[:variable].each do |bundle, variables|
+			bundle = bundle.to_s
+			@cluster[:variables][bundle] = {} if @cluster[:variables][bundle] == nil
+			variables.each do |variable,lines|
+				@cluster[:variables][bundle][variable] = [] if @cluster[:variables][bundle][variable] == nil
+				lines.each do |number,value|
+					@cluster[:variables][bundle][variable] << {:number=>number, :value=>value}
+				end
+			end
+		end
+	end
+	# Process Mixin Definition (Cluster)
+	def process_mixin_definition(definition)
+		definition.self[:mixin].each do |bundle, mixins|
+			bundle = bundle.to_s
+			@cluster[:mixins][bundle] = {} if @cluster[:mixins][bundle] == nil
+			mixins.each do |name, mixin|
+				mixin[:structure] = process_conditional_block(definition, _get_conditionals(mixin[:structure]),mixin[:structure],'loop')
+				@cluster[:mixins][bundle][name] = mixin
+			end
+		end
+	end
+	# Process Conditional (Cluster)
+	def process_conditional(definition)
+		definition.self[:hash] = process_conditional_block(definition, _get_conditionals(definition.self[:hash]), definition.self[:hash], 'loop')
+		definition.self[:hash] = process_conditional_block(definition, _get_conditionals(definition.self[:hash]), definition.self[:hash], 'if')
+	end
+	# Process Conditional Block
+	def process_conditional_block(definition, conditionals, lines, type)
+		conditional = conditionals.select{|k|k[:name].downcase == type}.sort_by{|k|k[:index]}.reverse
+		if conditional.count > 0
+			conditional = conditional.first
+			conditional_lines = []
+			definition_before = lines[0...(conditional[:c_index]-1)]
+			definition_after = lines[conditional[:end][:c_index]..lines.count]
+			if type == 'loop'
+				if is_number?(conditional[:value])
+					for i in 1..conditional[:value].to_i
+						value = i.to_s
+						loop_line = Marshal.load(Marshal.dump(lines.select{|k|k[:c_index] > conditional[:c_index] and k[:c_index] < conditional[:end][:c_index]}))
+						loop_line.each do |line|
+							line[:index] = line[:index]-1
+							line[:text] = line[:text].gsub(/@@/,value) if line[:text] != nil
+							line[:value] = line[:value].gsub(/@@/,value) if line[:value] != nil
+							if line[:attribute] != nil
+								line[:attribute].each do |attribute|
+									line[:attribute][attribute[0]] = attribute[1].gsub(/@@/,value) if attribute[1] != nil
+								end
+							end
+							conditional_lines << line
+						end
+					end
+				else
+					conditional[:value].split(',').each do |value|
+						value = value.strip
+						loop_line = Marshal.load(Marshal.dump(lines.select{|k|k[:c_index] > conditional[:c_index] and k[:c_index] < conditional[:end][:c_index]}))
+						loop_line.each do |line|
+							line[:index] = line[:index]-1
+							line[:text] = line[:text].gsub(/@@/,value) if line[:text] != nil
+							line[:value] = line[:value].gsub(/@@/,value) if line[:value] != nil
+							if line[:attribute] != nil
+								line[:attribute].each do |attribute|
+									line[:attribute][attribute[0]] = attribute[1].gsub(/@@/,value) if attribute[1] != nil
+								end
+							end
+							conditional_lines << line
+						end
+					end
+				end
+			elsif type == 'if'
+				regex = /(?<a>.+?)\s{1,}?(?<expression>==|!=|>=|<=|>|<|eq|neq|gte|lte|gt|lt)\s{1,}?(?<b>.+)/
+				match = conditional[:value].to_s.gsub(regex).each do
+					continue = false
+					if is_number? $1 and is_number? $3
+						if ['=','==','eq'].include?($2.to_s.downcase)
+							continue = true if $1.to_i == $3.to_i
+						elsif ['!=','neq'].include?($2.to_s.downcase)
+							continue = true if $1.to_i != $3.to_i
+						elsif ['>=','gte'].include?($2.to_s.downcase)
+							continue = true if $1.to_i >= $3.to_i
+						elsif ['<=','lte'].include?($2.to_s.downcase)
+							continue = true if $1.to_i <= $3.to_i
+						elsif ['>','gt'].include?($2.to_s.downcase)
+							continue = true if $1.to_i > $3.to_i
+						elsif ['<','lt'].include?($2.to_s.downcase)
+							continue = true if $1.to_i < $3.to_i
+						end
+					else
+						if ['=','==','eq'].include?($2.to_s.downcase)
+							continue = true if $1.to_s == $3.to_s
+						elsif ['!=','neq'].include?($2.to_s.downcase)
+							continue = true if $1.to_s != $3.to_s
+						end
+					end
+					conditional_lines = Marshal.load(Marshal.dump(lines.select{|k|k[:c_index] > conditional[:c_index] and k[:c_index] < conditional[:end][:c_index]})) if continue
+					conditional_lines.each do |line|
+						line[:index] = line[:index]-1
+					end
+				end
+			end
+			lines = definition_before.concat(conditional_lines).concat(definition_after)
+			conditionals = _get_conditionals(lines)
+			lines = process_conditional_block(definition,conditionals,lines, type) if conditionals.select{|k|k[:name].downcase == type}.count > 0
+		end
+		lines
+	end
+
+	def is_number?(value)
+    	value.to_f.to_s == value.to_s || value.to_i.to_s == value.to_s
+  	end
+
+	# Get Conditionals
+	def _get_conditionals(lines)
+		conditional_line = []
+		conditional_block = []
+		condition_open = 0
+		condition_index = 0
+		last_line = false
+		lines.each_with_index do |line,index|
+			line[:c_index] = index + 1
+		end
+		lines.select{|k|k[:type] == :conditional}.each do |line|
+			if line[:name].downcase != 'end'
+				condition_open = condition_open + 1
+			else
+				condition_open = condition_open - 1
+			end
+			conditional_block[condition_index] = [] if conditional_block[condition_index] == nil
+			conditional_block[condition_index] << line
+			condition_index = condition_index + 1 if condition_open == 0
+		end
+		conditional = []
+		conditional_block.each do |block|
+			block_open = block.select{|k|k[:name].downcase != 'end'}
+			block_close = block.select{|k|k[:name].downcase == 'end'}
+			close_block = []
+			count = 0
+			block_close.each_with_index do |close, index|
+				if close_block.count == 0
+					close_block << close
+				else
+					if close_block[index-1][:index] == close[:index]
+						close_block.insert(index-1-count, close)
+						count += 1
+					else
+						close_block << close
+					end
+				end
+			end
+			close_block = close_block.reverse
+			block_open.each_with_index do |line, index|
+				line[:end] = {:c_index=>close_block[index][:c_index], :value=> close_block[index][:value]}
+				conditional << line
+			end
+		end
+		conditional
+	end
+end

data/lib/aml/Compile.rb

@@ -0,0 +1,217 @@
+class Compile
+	require "aml/Prepare"
+	def initialize(argument)
+		@argument = argument
+		file = @argument.get('build')
+		@prepare = Prepare.new(file)
+		@inline = [
+			{:type=> :attribute, :regex=> /@\(\:(?<name>[\w|\-]+)\)/},
+			{:type=> :method, :regex=> /::((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)(\{(?<attribute>.+)\})?/},
+			{:type=> :variable, :regex=> /\@\(((?<bundle>[\w|\-]+)\.)?(?<name>[\w|\-]+)\)/}
+		]
+		@prepare.cluster.variables['false'] = {} if @prepare.cluster.variables.include?('false') == false
+		local = [
+			{:name=> 'file-created', :value=> Time.new.strftime('%Y-%m-%d %H:%M:%S')},
+			{:name=> 'file-name', :value=> File.basename(file)},
+			{:name=> 'file-path', :value=> File.expand_path(file)}
+		].each do |variable|
+			@prepare.cluster.variables['false'][variable[:name].to_s] = [{:number=>0, :value=>variable[:value].to_s}]
+		end
+
+		@log = []
+
+		@prepare.log.each do |log|
+			if log[:type] == "mixin"
+				@log << log if log[:bundle] != false
+			else
+				@log << log
+			end
+		end
+		
+
+		if @log.count == 0
+			process
+			@prepare.cluster.post_process
+		end
+
+	end
+	def log
+		@log
+	end
+	def structure
+		@prepare.cluster.definition.select{|k|k.self[:type] == "base"}.first.self[:hash]
+	end
+	def process
+		@prepare.cluster.definition.each do |definition|
+			definition.self[:hash].each_with_index do |line, index|
+				process_variable_and_method(line, index, definition)
+				process_mixin(line, index, definition)
+				process_partial(line, index, definition)
+			end
+		end
+		process if @prepare.cluster.definition.select{|k|k.self[:type] == "base"}.first.self[:hash].select{|k|k[:type] == :mixin or k[:type] == :partial}.count > 0
+	end
+	def post_process
+		@prepare.cluster.definition.each do |definition|
+			definition.self[:hash].each_with_index do |line, index|
+				process_variable_and_method(line, index, definition, true)
+			end
+		end
+	end
+	private
+	def has_match?(string, regex)
+		return string.to_s.match(regex) != nil
+	end
+	def process_variable_and_method(line, index, definition,  methods=false)
+		definition.self[:hash][index] = process_variable_line(line, definition)
+		definition.self[:hash][index] = process_method_line(line, definition) if methods
+	end
+	def process_variable_line(line, definition)
+		if line[:type] == :string
+			line[:value] = process_variable_find(line[:value], line, definition)
+			parse = Parse.new(definition.self[:bundle])
+			line = parse.line("#{"\t" * line[:index]}#{line[:value]}",line[:number])
+		else
+			line[:text] = process_variable_find(line[:text], line, definition)
+			line[:value] = process_variable_find(line[:value], line, definition)
+			if line.key? :attribute != nil
+				line[:attribute].each do|k,v|
+					line[:attribute][k] = process_variable_find(v, line, definition)
+				end
+			end
+		end
+		line
+	end
+	def process_method_line(line, definition)
+		if line[:type] == :string
+			line[:value] = process_method_find(line[:value], line)
+			parse = Parse.new(definition.self[:bundle])
+			line = parse.line("#{"\t" * line[:index]}#{line[:value]}",line[:number])
+		else
+			line[:text] = process_method_find(line[:text], line)
+			if line.key? :attribute != nil
+				line[:attribute].each do|k,v|
+					line[:attribute][k] = process_method_find(v, line)
+				end
+			end
+		end
+		line
+	end
+	def process_variable_find(string, line, definition)
+		regex = @inline.select{|k|k[:type] == :variable}[0][:regex]
+		string = string.to_s.gsub(regex).each do
+			process_variable_replace($1, $2, line[:number], definition)
+		end
+ 		string = process_variable_find(string, line, definition) if has_match?(string, regex)
+		return string
+	end
+	def process_method_find(string, line)
+		regex = @inline.select{|k|k[:type] == :method}[0][:regex]
+		string = string.to_s.gsub(regex).each do
+			process_method_replace($1, $2, $3, line[:index])
+		end
+ 		string = process_method_find(string, line) if has_match?(string, regex)
+		return string
+	end
+	def process_variable_replace(bundle, name, number, definition)
+		bundle = false.to_s if bundle == nil
+		number = 0 if bundle != "false"
+		begin
+			@prepare.cluster.variables.reject{|k| k != bundle}.first.last.reject{|k| k != name}.first.last.select{|k| if number != 0 then k[:number] < number else k[:number] == k[:number] end}.last[:value]
+		rescue
+			@log << {:fail=>false, :file=>definition.self[:file], :bundle=>definition.self[:bundle], :line=>number, :message=>"#{bundle.to_s != false.to_s ? bundle+"." : nil}#{name} variable does not exist; ignored."}
+			return nil
+		end
+	end
+	def process_method_replace(bundle, name, attribute, index)
+		bundle = 'core' if bundle == nil
+		begin
+			file = bundle == 'core' ? File.join(File.dirname(File.expand_path(__FILE__)),'core','method.rb') : File.join(File.dirname(File.expand_path(definition.self[:file])),line[:bundle],'method.rb')
+			Compile.class_eval File.read(file)
+			method_attribute = Line.new(bundle, :string, @inline.select{|k|k[:type] == :method}[0][:regex])
+			method_attribute = method_attribute.match?("::#{bundle}.#{name}{#{attribute}}", index)
+			attribute = method_attribute[:attribute]
+			Compile.const_get(bundle.split('-').map{|k|k.capitalize}.join).method(name).call(index, attribute)
+		rescue
+			return nil
+		end
+	end
+	def process_mixin(line, index, definition)
+		if line[:type] == :mixin
+			definition.self[:hash].delete_at index
+			mixin = process_mixin_find(line, line[:index], definition)
+			if mixin.is_a? Hash
+				mixin[:structure].each_with_index do |mixin_line, mixin_index|
+					definition.self[:hash].insert(index+mixin_index, mixin_line)
+				end
+			else
+				@log << {:fail=>false, :file=>definition.self[:file], :bundle=>definition.self[:bundle], :line=>line[:number], :message=>"#{line[:bundle] ? line[:bundle]+ '.' : nil}#{line[:name]} mixin does not exist; ignored."}
+			end
+		end
+	end
+	def process_mixin_find(line, offset=0, definition)
+		begin
+			mixin = Marshal.load(Marshal.dump(@prepare.cluster.mixins.reject{|k|k != line[:bundle].to_s}.first.last.reject{|k|k != line[:name]}.first.last))
+			mixin[:attribute] = mixin[:attribute].merge(line[:attribute])
+			mixin[:attribute].each do |attribute, value|
+				mixin[:attribute][attribute] = process_variable_find(value, line, definition)
+			end
+			mixin[:structure].each do |mixin_line|
+				mixin_line[:index] += offset
+				mixin_line[:number] = line[:number]
+				mixin_line = process_attribute(mixin_line, mixin)
+				mixin_line = process_variable_line(mixin_line, definition)
+			end
+			return mixin
+		rescue
+			return false
+		end
+	end
+	def process_attribute(line, mixin)
+		if line[:type] == :string
+			line[:value] = process_attribute_find(line[:value], mixin[:attribute])
+		else
+			line[:text] = process_attribute_find(line[:text], mixin[:attribute])
+			if line[:attribute] != nil
+				line[:attribute].each do|k,v|
+					line[:attribute][k] = process_attribute_find(v, mixin[:attribute])
+				end
+			end
+		end
+		line
+	end
+	def process_attribute_find(string, attribute)
+		regex = @inline.select{|k|k[:type] == :attribute}[0][:regex]
+		string = string.to_s.gsub(regex).each do
+			attribute[$1.to_sym].to_s
+		end
+		string = process_attribute_find(string,attribute) if has_match?(string, regex)
+		return string
+	end
+	def process_partial(line, index, definition)
+		if line[:type] == :partial
+			definition.self[:hash].delete_at index
+			partial = process_partial_find(line, line[:index], definition)
+			if partial.is_a? Array
+				partial.each_with_index do |partial_line,partial_index|
+					definition.self[:hash].insert(index+partial_index,partial_line)
+				end
+			end
+		end
+	end
+	def process_partial_find(line, offset, definition)
+		path = line[:bundle].to_s == false.to_s ? "partial" : line[:bundle].to_s
+		partial_number = line[:number]
+		patrial_attribute = line[:attribute]
+		partial = Definition.new(File.join(@argument.get('path'),path,line[:name]+'.aml'), line[:type].to_s, line[:bundle])
+		partial.self[:hash].each_with_index do |line, index|
+			line[:number] = partial_number
+			line = process_attribute(line, {:attribute=>patrial_attribute})
+			line = process_variable_line(line, definition)
+		end
+		partial.self[:hash].each do|line|
+			line[:index] += offset
+		end
+		partial.self[:hash]
+	end
+end

data/lib/aml/Definition.rb

@@ -0,0 +1,71 @@
+class Definition
+	require "aml/Parse"
+	def initialize(file, type, bundle=false)
+		@log = []
+		@definition = {}
+		@definition[:file] = file
+		@definition[:type] = type
+		@definition[:bundle] = bundle
+		@definition[:hash] = []
+		@definition[:variable] = {}
+		@definition[:mixin] = {}
+		number = 0
+		begin
+			parse = Parse.new(bundle)
+			# Remove Comment Line(s)
+			File.open(file).read.gsub(/%!--[^%]*--%$/,'').each_line do |line|
+				number+=1
+				# Remove Empty Lines
+				add_line(parse.line(line,number))
+			end
+			process_variable_definition
+			process_mixin_definition
+			
+		rescue Exception => e
+			@log << {:fail=>true, :file=>@definition[:file], :type=>@definition[:type], :bundle=> bundle, :message=>'file does not exist.'}
+			false
+		end
+	end
+	def log
+		@log
+	end
+	def self
+		@definition
+	end
+	private
+	def add_line(line)
+		@definition[:hash] << line if line[:type] != :empty
+	end
+	# Process Variable Definition (Local)
+	def process_variable_definition
+		@definition[:hash].reject{|k,v| k[:type] != :variable_definition}.each do |variable|
+			variable[:bundle] = variable[:bundle].to_s
+			@definition[:variable][variable[:bundle]] = {} if @definition[:variable].has_key?(variable[:bundle]) == false
+			@definition[:variable][variable[:bundle]][variable[:name]] = {} if @definition[:variable][variable[:bundle]].has_key?(variable[:name]) == false
+			@definition[:variable][variable[:bundle]][variable[:name]][variable[:number]] = variable[:value]
+		end
+		@definition[:hash] = @definition[:hash].reject{|k,v| k[:type] == :variable_definition}
+	end
+	# Process Mixin Definition (Local)
+	def process_mixin_definition
+		mixin_definition = @definition[:hash].reject{|k|k[:type] != :mixin_definition}
+		mixin_definition_end = @definition[:hash].reject{|k|k[:type] != :mixin_end}
+		if mixin_definition.count == mixin_definition_end.count
+			mixin_definition.each_with_index do |mixin,index|
+				@definition[:mixin][@definition[:bundle]] = {} if @definition[:mixin].has_key?(@definition[:bundle]) == false
+				if @definition[:mixin][@definition[:bundle]].has_key?(mixin[:name]) == false
+					@definition[:mixin][@definition[:bundle]][mixin[:name]] = {
+						:attribute => mixin[:attribute],
+						:structure => @definition[:hash].reject{|k,v| k[:number].between?(mixin[:number]+1,mixin_definition_end[index][:number]-1) == false}
+					}
+					@definition[:mixin][@definition[:bundle]][mixin[:name]][:structure].each do |line|
+						line[:index]-=1
+					end
+				else
+					@log << {:fail=>false, :file=>@definition[:file], :bundle=>@definition[:bundle], :line=>mixin[:number], :message=>"#{mixin[:name]} duplicate mixin definition; ignored."}
+				end
+				@definition[:hash] = @definition[:hash].reject{|k,v| k[:number].between?(mixin[:number],mixin_definition_end[index][:number])}
+			end
+		end
+	end
+end