sfp 0.1.0

data/lib/sfp/Sfplib.rb

@@ -0,0 +1,357 @@
+module Sfp
+	module SfpLangHelper
+		attr_accessor :root_dir, :home_dir
+		attr_reader :root, :used_classes, :arrays, :conformant
+
+		def init
+			@root = Hash.new
+			@now = @root
+			@id = 0
+			@root['Object'] = { '_self' => 'Object', '_context' => 'class', '_parent' => @root }
+			@unexpanded_classes = Array.new
+			@used_classes = Array.new
+			@arrays = Hash.new
+			@conformant = false
+		end
+
+		def next_id
+			nid = "c" + @id.to_s
+			@id += 1
+			return nid
+		end
+	
+		def null_value(isa=nil)
+			return { '_context' => 'null', '_isa' => isa }
+		end
+	
+		def to_ref(path)
+			ref = "$." + path
+			return ref
+		end
+	
+		def to_sfp
+			return @root
+		end
+
+		def create_constraint(name, type='and')
+			return { '_self' => name,
+				'_context' => 'constraint',
+				'_type' => type,
+				'_parent' => @now
+			}
+		end
+
+		def process_file(file)
+			filepath = file
+			filepath = @root_dir + "/" + file if not @root_dir.nil? and file[0,1] != '/'
+			filepath = @home_dir + "/" + file if not @home_dir.nil? and not File.exist?(filepath)
+
+			raise Exception, 'File not found: ' + file if not File.exist?(filepath)
+
+			new_home_dir = File.expand_path(File.dirname(filepath))
+			parser = Sfp::Parser.new({:root_dir => @root_dir, :home_dir => new_home_dir})
+			parser.parse(File.read(filepath))
+
+			parser.root.each_pair { |key,val|
+				if val['_context'] == 'class' or val['_context'] == 'composite'
+					@root[key] = val
+				elsif val['_context'] == 'state' or val['_context'] == 'constraint'
+					if @root.has_key?(key)
+						if @root[key]['_context'] != val['_context']
+							@root[key] = val
+						else
+							val['_context'].each_pair { |k2,v2| @root[key][k2] = v2 }
+						end
+					else
+						@root[key] = val
+					end
+				end
+			}
+		end
+	
+		def goto_parent(remove_parent=false)
+			n = @now
+			@now = @now['_parent']
+			n.delete('_parent') if remove_parent
+			return n
+		end
+
+		def expand_classes
+			@unexpanded_classes.each { |c|
+				sclass = @root.at?(c['_extends'])
+				c.inherits( sclass )
+				c['_super'] = (sclass.has_key?('_super') ? sclass['_super'].clone : Array.new)
+				c['_super'] << c['_extends']
+			}
+		end
+
+		def expand_object(obj)
+			return false if not Sfp::Helper.expand_object(obj, @root)
+			@used_classes = @used_classes.concat(obj['_classes']).uniq
+		end
+
+		def deep_clone(value)
+			if value.is_a?(Hash)
+				result = value.clone
+				value.each { |k,v|
+					if k != '_parent'
+						result[k] = deep_clone(v)
+						result[k]['_parent'] = result if result[k].is_a?(Hash) and result[k].has_key?('_parent')
+					end
+				}
+				result
+			elsif value.is_a?(Array)
+				result = Array.new
+				value.each { |v| result << deep_clone(v) }
+				result
+			else
+				value
+			end
+		end
+	end
+
+	module Helper
+		def self.deep_clone(value)
+			if value.is_a?(Hash)
+				result = value.clone
+				value.each { |k,v|
+					if k != '_parent'
+						result[k] = deep_clone(v)
+						result[k]['_parent'] = result if result[k].is_a?(Hash) and result[k].has_key?('_parent')
+					end
+				}
+				result
+			elsif value.is_a?(Array)
+				result = Array.new
+				value.each { |v| result << deep_clone(v) }
+				result
+			else
+				value
+			end
+		end
+
+		def self.to_json(sfp)
+			root = Sfp::Helper.deep_clone(sfp)
+			root.accept(Sfp::Visitor::ParentEliminator.new)
+			return JSON.generate(root)
+		end
+
+		def self.to_pretty_json(sfp)
+			root = Sfp::Helper.deep_clone(sfp)
+			root.accept(Sfp::Visitor::ParentEliminator.new)
+			return JSON.pretty_generate(root)
+		end
+
+		def self.expand_object(obj, root)
+			return false if obj == nil or root == nil or
+					not obj.has_key?('_isa') or obj['_isa'] == nil
+			objclass = root.at?(obj['_isa'])
+			if objclass.nil? or objclass.is_a?(Sfp::Unknown) or objclass.is_a?(Sfp::Undefined)
+				raise Exception, 'Super class is not found: ' + obj['_self'] + ' < ' + obj['_isa']
+			end
+			obj.inherits( objclass )
+			obj['_classes'] = (objclass.has_key?('_super') ? objclass['_super'].clone : Array.new)
+			obj['_classes'] << obj['_isa']
+			return true
+		end
+	end
+
+
+	class Null
+		attr_accessor :type
+	end
+
+	# Instance of this class will be returned as the value of a non-exist variable
+	class Undefined
+		attr_accessor :path
+		def initialize(path=nil); @path = path; end
+		def to_s; (@path.nil? ? "<sfp::undefined>" : "<sfp::undefined[#{@path}]>"); end
+	end
+
+	# Instance of this class will be return as the value of an unknown variable
+	# in open-world assumption.
+	class Unknown
+		attr_accessor :path
+		def initialize(path=nil); @path = path; end
+		def to_s; (@path.nil? ? "<sfp::unknown>" : "<sfp::unknown[#{@path}]>"); end
+	end
+end
+
+# return a fullpath of reference of this context
+Hash.send(:define_method, "ref") {
+	return '$' if not self.has_key?('_parent') or self['_parent'] == nil
+	me = (self.has_key?('_self') ? self['_self'] : '')
+	return self['_parent'].ref + "." + me
+}
+
+# accept method as implementation of Visitor pattern
+Hash.send(:define_method, "accept") { |visitor|
+	keys = self.keys
+	keys.each do |key|
+		next if key == '_parent' or not self.has_key?(key)
+		value = self[key]
+		go_next = visitor.visit(key, value, self)
+		value.accept(visitor) if value.is_a?(Hash) and go_next == true
+	end
+}
+
+# resolve a reference, return nil if there's no value with given address
+Hash.send(:define_method, "at?") { |addr|
+	return Sfp::Unknown.new if not addr.is_a?(String)
+
+	addrs = addr.split('.', 2)
+
+	if addrs[0] == '$'
+		return self.root.at?(addrs[1])
+	elsif addrs[0] == 'root'
+		return self.root.at?(addrs[1])
+	elsif addrs[0] == 'this' or addrs[0] == 'self'
+		return self.at?(addrs[1])
+	elsif addrs[0] == 'parent'
+		return nil if not self.has_key?('_parent')
+		return self['_parent'] if addrs[1].nil?
+		return self['_parent'].at?(addrs[1])
+	elsif self.has_key?(addrs[0])
+		if addrs.length == 1 
+			return self[addrs[0]]
+		else
+			return self[addrs[0]].at?(addrs[1]) if self[addrs[0]].is_a?(Hash) and addrs[1] != ''
+		end
+	end
+
+	return Sfp::Unknown.new
+}
+
+Hash.send(:define_method, "type?") { |name|
+	return nil if not self.has_key?(name)
+	value = self[name]
+	if value != nil
+		return '$.Boolean' if value.is_a?(TrueClass) or value.is_a?(FalseClass)
+		return '$.Integer' if value.is_a?(Numeric)
+		return '$.String' if value.is_a?(String) and not value.isref
+		return value['_isa'] if value.isobject or value.isnull
+		return "(#{value['_isa']})" if value.is_a?(Hash) and value.isset and value.has_key?('_isa')
+	end
+
+	return nil
+}
+
+# return root context of this context
+Hash.send(:define_method, "root") {
+	return self if not self.has_key?('_parent') or self['_parent'] == nil
+	return self['_parent'].root
+}
+
+# return true if this context is a constraint, otherwise false
+Hash.send(:define_method, "isconstraint") {
+	return (self.has_key?('_context') and self['_context'] == 'constraint')
+}
+
+Hash.send(:define_method, "isset") {
+	return (self.has_key?('_context') and self['_context'] == 'set')
+}
+
+Hash.send(:define_method, "isprocedure") {
+	return (self.has_key?('_context') and self['_context'] == 'procedure')
+}
+
+# return true if this context is a class, otherwise false
+Hash.send(:define_method, "isclass") {
+	return (self.has_key?('_context') and self['_context'] == 'class')
+}
+
+# return superclass' reference if this context is a sub-class, otherwise nil
+Hash.send(:define_method, "extends") {
+	return self['_extends'] if self.isclass and self.has_key?('_extends')
+	return nil
+}
+
+# return true if this class has been expanded, otherwise false
+Hash.send(:define_method, "expanded") {
+	@expanded = false if not defined?(@expanded)
+	return @expanded
+}
+
+# copy attributes and procedures from superclass to itself
+Hash.send(:define_method, 'inherits') { |parent|
+	return if not parent.is_a?(Hash)
+	parent.each_pair { |key,value|
+		next if key[0,1] == '_' or self.has_key?(key)
+		if value.is_a?(Hash)
+			self[key] = Sfp::Helper.deep_clone(value)
+			self[key]['_parent'] = self
+		else
+			self[key] = value
+		end
+	}
+	@expanded = true
+}
+
+# return true if this context is an object, otherwise false
+Hash.send(:define_method, 'isobject') {
+	return (self.has_key?('_context') and self['_context'] == 'object')
+}
+
+Hash.send(:define_method, 'isa') {
+	return nil if not self.isobject or not self.has_key?('_isa')
+	return self['_isa']
+}
+
+Hash.send(:define_method, 'isvalue') {
+	return self.isobject
+}
+
+Hash.send(:define_method, 'isnull') {
+	return (self.has_key?('_context') and self['_context'] == 'null')
+}
+
+Hash.send(:define_method, 'iseither') {
+	return (self['_context'] == 'either')
+}
+
+Hash.send(:define_method, 'tostring') {
+	return 'null' if self.isnull
+	return self.ref
+}
+
+# add path to the end of a reference 
+String.send(:define_method, "push") { |value|
+	return self.to_s + "." + value
+}
+
+# return first element and keep the rest
+String.send(:define_method, 'explode') {
+	return self.split('.', 2)
+}
+
+# return an array of [ parent, last_element]
+String.send(:define_method, 'pop_ref') {
+	return self.extract
+}
+
+# return an array of [ parent, last_element ]
+String.send(:define_method, 'extract') {
+	return self if not self.isref
+	parts = self.split('.')
+	return self if parts.length <= 1
+	last = parts[ parts.length - 1 ]
+	len = self.length - last.length - 1
+	return [self[0, len], last]
+}
+
+
+# return true if this string is a reference, otherwise false
+String.send(:define_method, 'isref') {
+	s = self.to_s
+	return true if (s.length > 0 and s[0,1] == '$')
+	return false
+}
+
+# return the parent of this path
+# e.g.: if self == 'a.b.c.d', it will return 'a.b.c'
+String.send(:define_method, 'to_top') {
+	return self if self == '$'
+	parts = self.split('.')
+	return self[0, self.length - parts[parts.length-1].length - 1]
+}
+

data/lib/sfp/parser.rb

@@ -0,0 +1,128 @@
+module Sfp
+	# main class which processes configuration description in SFP language either
+	# in file or as a string
+	class Parser
+		# enable this class to process SFP into FDR (SAS+)
+		include Sfp::SasTranslator
+
+		attr_accessor :root_dir, :home_dir, :conformant
+
+		def initialize(params={})
+			@root_dir = (params[:root_dir].is_a?(String) ?
+			             params[:root_dir].strip :
+			             nil)
+			@home_dir = (params[:home_dir].is_a?(String) ?
+			             params[:home_dir].strip :
+			             nil)
+			@root = params[:root]
+			@conformant = !!params[:conformant]
+		end
+
+		# @param string : a string in SFP language
+		def parse(string)
+			lexer = SfpLang::Lexer.new(string)
+			tokens = ANTLR3::CommonTokenStream.new(lexer)
+			parser = SfpLang::Parser.new(tokens)
+			parser.root_dir = @root_dir
+			parser.home_dir = @home_dir
+			parser.sfp
+			@root = parser.root
+			@conformant = parser.conformant
+			@parser_arrays = parser.arrays
+		end
+
+=begin
+		# Parse SFP file and return its JSON representation
+		def self.parse_file(file)
+			return file_to_sfp(file)
+		end
+
+		def self.file_to_sfp(file)
+			parser = Parser.new
+			parser.parse_file(file)
+			return parser.to_sfp
+		end
+
+		def self.to_sfp(string)
+			parser = Parser.new
+			parser.parse(string)
+			return parser.to_sfp
+		end
+
+		# parse SFP file
+		def parse_file(file)
+			f = File.open(file, 'rb')
+			lexer = SFP::Lexer.new(f)
+			tokens = ANTLR3::CommonTokenStream.new(lexer)
+			parser = SFP::Parser.new(tokens)
+			parser.root_dir = (@root_dir == nil or @root_dir == '' ?
+					File.expand_path('.') : @root_dir)
+			parser.home_dir = File.dirname(f.path)
+			parser.sfp
+			@conformant = parser.conformant
+			@root = parser.root
+			@parser_arrays = parser.arrays
+		end
+
+		# parse SFP in a string
+		def parse(text)
+			lexer = SFP::Lexer.new(text)
+			tokens = ANTLR3::CommonTokenStream.new(lexer)
+			parser = SFP::Parser.new(tokens)
+			parser.root_dir = (@root_dir == nil or @root_dir == '' ?
+					File.expand_path(File.dirname('.')) : @root_dir)
+			parser.home_dir = parser.root_dir
+			parser.sfp
+			@root = parser.root
+			@parser_arrays = parser.arrays
+		end
+
+		# dump the parsed specification into standard output
+		def dump(root=nil)
+			return if root == nil
+			root = Nuri::Sfp.deep_clone(@root)
+			root.accept(ParentEliminator.new)
+			puts JSON.pretty_generate(root)
+		end
+
+		def self.dump(root)
+			return if root == nil
+			root = Nuri::Sfp.deep_clone(root)
+			root.accept(ParentEliminator.new)
+			puts JSON.pretty_generate(root)
+		end
+
+		def to_sfp
+			@root
+		end
+
+		def to_json
+			root = self.to_sfp
+			return if root == nil
+			root = Nuri::Sfp.deep_clone(root)
+			return Nuri::Sfp.to_json(root)
+		end
+=end
+
+		def to_json(params={})
+			return '' if @root.nil?
+			return Sfp::Helper.to_pretty_json(@root) if params[:pretty]
+			return Sfp::Helper.to_json(@root)
+		end
+	end
+
+=begin
+	def self.to_json(sfp)
+		root = Sfp::Helper.deep_clone(sfp)
+		root.accept(Nuri::Sfp::ParentEliminator.new)
+		return JSON.generate(root)
+	end
+
+	def self.to_pretty_json(sfp)
+		root = Nuri::Sfp.deep_clone(sfp)
+		root.accept(Nuri::Sfp::ParentEliminator.new)
+		return JSON.pretty_generate(root)
+	end
+=end
+
+end