iab-Oil 0.1.2

data/lib/RatingEngineResolver.rb

@@ -0,0 +1,87 @@
+require 'DSLContext'
+
+class RatingEngineResolver < DslContext
+
+  bubble :than, :is, :list, :the, :to, :at, :it
+  
+  def dictionary(*args)
+    xml = "<?xml version='1.0' encoding='UTF-8'?>"
+    xml << "<PolMessage Type='TransactionRequestConfig' Version='1'>" if args[0] == "XML"
+    xml << "<PolMessage Type='TransactionRequest' Version='1'>" if args[0] != "XML"
+    xml << "<Dictionary DictType='#{args[0]}' DictName='#{args[1]}' DictId='#{args[2]}' DictVer='#{args[3]}'/>"
+    xml << "<Transaction TranName='QuotationRequest' EffectiveDate='2007-04-30'/>" if args[0] == "XML"
+    xml << "<Transaction TranName='QuoteDetail' EffectiveDate='17/7/2007'/>" if args[0] != "XML"
+    xml << "<Schemes><Scheme Ref='#{args[4]}'/></Schemes>"
+    @dictHeader=xml   
+  end
+  
+  def rating_engine(*args)
+    @ratingEngine = args[0]
+    @responseContent = args[1]
+    if (args[2] != nil) then
+      @inboundTransform = args[2]
+    else
+      @inboundTransform = nil
+    end
+    if (args[3] != nil) then
+      @outboundTransform = args[3]
+    else
+      @outboundTransform = nil
+    end
+    if (args[4] != nil) then
+      @mockFile = args[4]
+    else
+      @mockFile = nil
+    end    
+  end
+  
+  def getResult
+    if (@ratingEngine == 'Mock') then
+      closure = "lambda {|xml| "
+      closure << "response = SBroker.GetMockRatingResponse('#{@mockFile}'); response"
+      closure << "}"
+      "#{closure}"
+    else
+      closure = "lambda {|xml| "
+      closure << "keep_xml = xml;"
+      if (@inboundTransform != nil) then
+          closure << "xml = SBroker.ApplyTransform(xml,'#{@inboundTransform}',nil); "
+      end
+      closure << "msg = \""
+      closure << @dictHeader
+      closure << "<PolData Type='Request' Selection='#{@responseContent}'/>"
+      closure << "<PolData Type='Input'>"
+      closure << "\""
+      closure << '+ xml +'
+      closure << "\""
+      closure << "</PolData></PolMessage>"
+          #puts '----------\n';p msg;puts '====\n';p response;    
+      closure << "\"; response = SBroker.InvokeRTE(msg);"
+      closure << "if (partial) then premium = SBroker.ExtractSectionPremium(keep_xml,response);premium else response end"     
+      closure << "}"
+      "#{closure}"
+    end
+  end
+
+  def product(name)
+      puts "say the product is #{name}"
+  end
+  
+  def supported_channels(*args)
+    puts "say supported channels are "
+    args.each do |arg|
+      puts "say "+arg
+    end
+  end
+
+  def supported_processes(*args)
+    puts "say supported processes are "
+    args.each do |arg|
+      puts "say "+arg
+    end
+  end
+  
+  def channel(name) 
+      puts " say it has a #{name} channel"  
+  end
+end

data/lib/SiteProcessInterpreter.rb

@@ -0,0 +1,65 @@
+require 'set'
+require File.join(File.dirname(__FILE__),'DSLContext')
+
+class SiteProcessInterpreter < DslContext
+  def initialize
+    @cmds = []
+    @processes = Hash.new #list of all the processes with the value of the first step being stored
+    @result = []
+    @result[0] = Hash.new
+    @result[1] = Array.new
+    @result[2] = Set.new
+  end
+
+  def getResult
+    #massage result[0] so that all navigation that related to processes are replaced with the 1st step of the process
+    #rather than the process name
+    #...
+    @result
+  end
+
+  def siteprocesses(*args)
+  end
+
+  def endsiteprocesses(*args)
+  end
+
+  def reference_datamodel(*args)
+  end
+
+  def process(*args)
+    @current_process = args[0]
+    @processes[@current_process.to_sym] = :FirstStepUnknown
+    @cmds.push :process
+  end
+
+  def endprocess(*args)
+  end
+
+  def products(*args)
+  end
+
+  def endproducts(*args)
+  end
+
+  def product(*args)
+    @result[1].push args[0]
+  end
+
+  def endproduct(*args)
+  end
+
+  #from here we can derive the product process DSL
+  #and also the layout files
+  def flow(*args)
+    if (@cmds.last == :process)
+      @processes[@current_process.to_sym] = args[0]
+    end
+    @cmds.push :flow
+
+    @result[0]["#{args[0]}".to_sym] = args[1]
+    args[1][:data_model].each do |e|
+      @result[2].add?(e.to_sym)
+    end
+  end
+end

data/lib/VPMSComponentSchemaInterpreter.rb

@@ -0,0 +1,216 @@
+require File.join(File.dirname(__FILE__),'DSLContext')
+require 'yaml'
+
+#create class that fills in for the RAILS class when rails is not around, e.g. when testing
+#when RAILS is around this will have no effect
+class HashWithIndifferentAccess < Hash
+end
+
+class VPMSComponentSchemaInterpreter < DslContext
+
+  #ToDo: Sends in an xpath statement to set up a referenceable context for the node
+  #in the transformation - i.e. when duplicating complex types
+
+  bubble :than, :is, :list, :the, :to, :at, :it, :end
+
+  VPMS_SCHEMA_INTERPRETER_ROOT = File.dirname(__FILE__)
+  XSL_ROOT = File.join(VPMS_SCHEMA_INTERPRETER_ROOT, 'xslt')
+  MOCK_ROOT = File.join(VPMS_SCHEMA_INTERPRETER_ROOT, 'mocks')
+
+   def initialize(*args)
+   		@props = args
+   		@useDynamicFileMapping = (args.length > 0) ? true : false
+		@hashesRoot = (args.length > 0) ? OIL_HASH_ROOT : ENTITY_DEF_ROOT
+   end
+   
+  def getResult
+      getResult = ""
+      getResult << startSchema
+      @erbAry.each do |a|
+        b = a.first
+        #a.to_s
+        getResult << "\t"
+        getResult << processXPath(a, b)
+      end
+      getResult << endSchema
+      getResult
+  end
+  
+  def processXPath(*args)
+    processXpath = ""
+    xpath = args[0]
+    boolEndOfPath = (args[0].length == 1)
+      processXpath << "\t"
+      processXpath << startElement(args[0].first, args[1], boolEndOfPath)
+      xpath.delete_at(0)
+      if xpath.length > 0
+        processXpath << startComplexType
+        processXpath << processXPath(xpath, args[1])
+        processXpath << endComplexType
+      end
+      processXpath << endElement
+    processXpath
+  end
+
+  def applyTransform(*args)
+      require 'rexml/document'
+      require 'xml/xslt'
+      xslt = XML::XSLT.new()
+      string = args[0]
+      doc = REXML::Document.new(string)
+      xslt.xml = doc
+      xslt.xsl = File.join(XSL_ROOT, "VPMSSchemaInterpreter.xsl")
+      transformed_xml = xslt.serve()
+      transformed_xml
+  end
+  
+  def startSchema
+    #ToDo: Make this a widget - a schema open widget for example
+    openSchema = ""
+    openSchema << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"
+    openSchema << "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n"
+    openSchema
+  end
+
+  def endSchema
+    endSchema = ""
+    endSchema << "</xs:schema>\n"
+    endSchema
+  end
+
+  def startElement(*args)
+    #ToDo: Make this a widget - an element open widget for example
+    openElement = ""
+    openElement << "<xs:element name=\"#{args[0]}\""
+    #ToDo: do something better to get type info - 
+    #if this is the ultimate point in the xpath, this pushes in a data type of string - thats all
+    if (args[2] == true) then
+      openElement << " type=\"xs:string\">\n"
+    else
+      openElement << ">\n"
+    end
+    #ToDo: Read the element type and other atts off the MD hash metadata.
+    #args 1 is the full xpath of the element used potentially to key into the md hash 
+    #Potentially do this if args 2 is true (it's the last xpath step) and use args 1 for the key
+    #args 2 represents a key into a hash
+    #the @metaProps hash for example - see 'coverage'
+    #If there is an entry in that hash for this element's xpath, then a type attribute can be
+    #determined for it and gets used from the md hash - When the element is nesting a ct, there's no type attribute
+    #This key would be used to read off values in that hash, if it is a hash of hashes - 
+    #i.e. if the buildingsCoverSumInsuredAmount key in the metaProps referenced a hash of metadata:
+    #It would also be possible to reference entries for this element in the existing 
+    #xml dictionary, which is keyed on this element's xpath
+    openElement
+  end
+
+  def endElement
+    endElement = ""
+    endElement << "</xs:element>\n"
+    endElement
+  end
+
+  def startComplexType
+    #ToDo: Make this a widget - a schema open widget for example
+    openElement = ""
+    openElement << "<xs:complexType>\n"
+    openElement << startSequence
+    openElement
+  end
+
+  def endComplexType
+    endElement = ""
+    endElement << endSequence
+    endElement << "</xs:complexType>\n"
+    endElement
+  end
+
+  def startSequence
+    #ToDo: Make this a widget - a schema open widget for example
+    openElement = ""
+    openElement << "<xs:sequence>\n"
+    openElement
+  end
+
+  def endSequence
+    endElement = ""
+    endElement << "</xs:sequence>\n"
+    endElement
+  end
+  
+  def coverage(*args)
+    @erbAry = []
+    @erb = ""
+    @argName = "#{args[0]}"
+    @useDynamicFileMapping == true ? io = open(File.join(@hashesRoot,"/coverages/#{@argName}PropertyHash"),'r' ) : io = open(File.join(COVERAGE_DEF_ROOT,"/#{@argName}PropertyHash"),'r' ) 
+    @prdhash = YAML::load(io)
+  end
+
+  def endcoverage(*args)
+  end
+
+  def entity(*args)
+    @erbAry = []
+    @erb = ""
+    @argName = "#{args[0]}"
+    @useDynamicFileMapping == true ? io = open(File.join(@hashesRoot,"/entities/#{@argName}PropertyHash"),'r' ) : io = open(File.join(ENTITY_DEF_ROOT,"/#{@argName}PropertyHash"),'r' ) 
+    @prdhash = YAML::load(io)
+  end
+
+  def endentity(*args)
+  end
+  
+  def use(*args)
+    
+    h = ""
+    lasth = ""
+    lasta = "" 
+    args.each do |a|
+      unless a.class == Hash
+      lasth = String.new(h)
+      h << "#{a}"
+      lasta = a
+      end
+    end
+
+    hashname = @argName + h
+    
+    #now figure out whether the last arg above leads to an empty hash
+    #i.e. it is really a single value field
+    #if so backup a level and read the property whose name = the last arg value passed in
+    
+    specificProperty = false
+	
+    if !@prdhash.has_key?(hashname)
+      puts "missing key for #{hashname} when processing:use #{args}"
+    end
+    myHash = @prdhash["#{hashname}"].clone
+    if (myHash.length == 1)
+      hashname = @argName + lasth
+      specificProperty = true
+    if !@prdhash.has_key?(hashname)
+      puts "missing key for #{hashname} when processing:use #{args}"
+    end
+      myHash = @prdhash["#{hashname}"].clone
+    end
+    
+    @erb << myHash["#{'xpath'}"]
+
+     myHash.each do |property, value|
+       if (property != 'xpath' and (property =~ /MD$/) == nil) then
+         if (value == "" && (!specificProperty || (specificProperty && property == "#{lasta}"))) then
+           @erb << "/"
+           @erb << property
+           #In progress
+           #@metaprop = @erb.sub('/', '') stands as an xpath key to the metadata in the 'element properties' hash
+           
+         end
+       end
+     end
+     
+     erbTemp = @erb.split('/')
+     @erbAry.push(erbTemp)
+     @erb = ""
+
+  end
+end
+

data/lib/VPMSPackageSchemaInterpreter.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__),'DSLContext')
+require File.join(File.dirname(__FILE__),'VPMSComponentSchemaInterpreter')
+require File.join(File.dirname(__FILE__),'CollesceProductInterpreter')
+require 'yaml'
+
+#create class that fills in for the RAILS class when rails is not around, e.g. when testing
+#when RAILS is around this will have no effect
+class HashWithIndifferentAccess < Hash
+end
+
+class VPMSPackageSchemaInterpreter < DslContext
+
+  bubble :than, :is, :list, :the, :to, :at, :it, :end
+  
+  VPMS_SCHEMA_INTERPRETER_ROOT = File.dirname(__FILE__)
+  XSL_ROOT = File.join(VPMS_SCHEMA_INTERPRETER_ROOT, 'xslt')
+  MOCK_ROOT = File.join(VPMS_SCHEMA_INTERPRETER_ROOT, 'mocks')
+  
+  def getResult
+    @entities = Hash.new
+    @coverages = Hash.new
+    getResult = ""
+    getResult << startSchema
+    if (@arProductsSplit != nil) then
+      @arProductsSplit.each do |a|
+          open(File.join(a,"/product.oil")) {|f| @contents = f.read }
+          dsl = @contents.to_s
+          h = CollesceProductInterpreter.execute(dsl)
+          @entities.merge!(h[0])
+          @coverages.merge!(h[1])
+          #open(File.join(a,"/product.oil")) {|f| @contents = f.read }
+          #dsl = @contents.to_s
+          #frag = VPMSProductSchemaInterpreter.execute(dsl,a)
+          #getResult << applyTransform(frag)
+      end
+      collescedProduct = "product :CommercialProperty\n"
+      collescedProduct << "entities\n"
+      @entities.each do |k,v|
+        collescedProduct << "#{v} :#{k}\n"
+      end
+      collescedProduct << "entities\n"
+      collescedProduct << "coverages\n"
+      @coverages.each do |k,v|
+        collescedProduct << "#{v} :#{k}\n"
+      end
+      collescedProduct << "coverages\n"
+      collescedProduct << "endproduct"
+      #puts collescedProduct
+      frag = VPMSProductSchemaInterpreter.execute(collescedProduct,"#{OIL_DSL_ROOT.gsub('*','')}Retailer/DSL")
+      getResult << applyTransform(frag)
+    end
+    getResult << endSchema
+  end
+  
+  def package(*args)
+	theDir = "#{OIL_DSL_ROOT}"
+	@schemaFragments = ""
+    @arProductsSplit = Array.new
+     Dir.glob(File.join(theDir, '*'), File::FNM_PATHNAME) do |p|
+      if File.directory?(p)
+      	@arProductsSplit.push(p)
+      end
+     end
+  end
+
+  def endpackage
+  end
+  
+  def startSchema
+    #ToDo: Make this a widget - a schema open widget for example
+    openSchema = ""
+    openSchema << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"
+    openSchema << "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n"
+    openSchema << "<xs:element xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" name=\"CommercialProperty\">\n"
+    openSchema << "<xs:complexType>\n"
+    openSchema << "<xs:sequence>\n"
+    openSchema
+  end
+
+  def endSchema
+    endSchema = ""
+    endSchema << "</xs:sequence>\n"
+    endSchema << "</xs:complexType>\n"
+    endSchema << "</xs:element>\n"
+    endSchema << "</xs:schema>\n"
+    endSchema
+  end
+
+  def applyTransform(*args)
+      require 'rexml/document'
+      require 'xml/xslt'
+      xslt = XML::XSLT.new()
+      string = args[0]
+      doc = REXML::Document.new(string)
+      xslt.xml = doc
+      xslt.xsl = File.join(XSL_ROOT, "VPMSPackageSchemaInterpreter.xsl")
+      transformed_xml = xslt.serve()
+      transformed_xml
+  end
+  
+end
+

data/lib/VPMSProductSchemaInterpreter.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(__FILE__),'DSLContext')
+require File.join(File.dirname(__FILE__),'VPMSComponentSchemaInterpreter')
+require 'yaml'
+
+#create class that fills in for the RAILS class when rails is not around, e.g. when testing
+#when RAILS is around this will have no effect
+class HashWithIndifferentAccess < Hash
+end
+
+class VPMSProductSchemaInterpreter < DslContext
+ 
+  bubble :than, :is, :list, :the, :to, :at, :it, :end
+  
+  VPMS_SCHEMA_INTERPRETER_ROOT = File.dirname(__FILE__)
+  XSL_ROOT = File.join(VPMS_SCHEMA_INTERPRETER_ROOT, 'xslt')
+  MOCK_ROOT = File.join(VPMS_SCHEMA_INTERPRETER_ROOT, 'mocks')
+   
+   def initialize(*args)
+   		@props = args
+   		@useDynamicFileMapping = (args.length > 0) ? true : false
+		@productDSLRoot = (args.length > 0) ? args[0] : ENTITY_DSL_ROOT
+   end
+  
+  def getResult
+      @getResult = ""
+      @getResult << getDenormalisedSchema
+  end
+
+  def getDenormalisedSchema
+      getSchema = ""
+      getSchema << startSchema
+      getSchema << startRoot(@classDef)
+      getSchema << @schemaFragments
+      getSchema << endRoot
+      getSchema << endSchema
+      getSchema
+  end
+  
+  def applyTransform(*args)
+      require 'rexml/document'
+      require 'xml/xslt'
+      xslt = XML::XSLT.new()
+      string = args[0]
+      doc = REXML::Document.new(string)
+      xslt.xml = doc
+      xslt.xsl = File.join(XSL_ROOT, "VPMSSchemaInterpreter.xsl")
+      transformed_xml = xslt.serve()
+      transformed_xml
+  end
+  
+  def startSchema
+    #ToDo: Make this a widget - a schema open widget for example
+    openSchema = ""
+    openSchema << "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n"
+    openSchema
+  end
+  
+  def endSchema
+    endSchema = ""
+    endSchema << "</xs:schema>\n"
+    endSchema
+  end
+
+  def startRoot(*args)
+    #ToDo: Make this a widget - an element open widget for example
+    openElement = ""
+    openElement << "<xs:element name=\"#{args[0]}\">\n"
+    openElement << "<xs:complexType>\n"
+    openElement << "<xs:sequence>\n"
+    openElement << "<xs:element name=\"Brand\" type=\"xs:string\"/>\n"
+    openElement << "<xs:element name=\"Package\" type=\"xs:string\"/>\n"
+    openElement
+  end
+
+  def endRoot
+    endElement = ""
+    endElement << "</xs:sequence>\n"
+    endElement << "</xs:complexType>\n"
+    endElement << "</xs:element>\n"
+    endElement
+  end
+
+  def product(*args)
+    @requires = ""
+    @schemaFragments = ""
+    @classDef = "#{args[0]}"
+  end
+  
+  def endproduct
+    
+  end
+  
+  def entities(*args)
+    @libtype = "entities"
+  end
+  
+  def endentities
+    
+  end
+  
+  def coverages(*args)
+    @libtype = "coverages"
+  end
+  
+  def endcoverages
+    
+  end
+  
+  def for_ABI_codes(*args)
+  end
+  
+  def conditional_on(*args)
+  end
+  
+  def has_one(*args)
+  	has(args)
+  end
+
+  def has_many(*args)
+  	has(args)
+  end
+
+	def has(*args)
+  		if (@useDynamicFileMapping == true) then
+  			open(File.join(@productDSLRoot,"#{@libtype}/#{args[0]}.oil")) {|f| @contents = f.read }
+  		else
+  			open(File.join(@productDSLRoot,"/#{args[0]}.oil")) {|f| @contents = f.read }
+  		end
+    	dsl = @contents.to_s
+    	# todo: bit clumsy but need it working
+    	if (@useDynamicFileMapping == true) then
+    		frag = VPMSComponentSchemaInterpreter.execute(dsl,@useDynamicFileMapping)
+    	else
+    		frag = VPMSComponentSchemaInterpreter.execute(dsl)
+    	end
+    	@schemaFragments << applyTransform(frag)
+	end
+
+  def has_between(*args)
+  		if (@useDynamicFileMapping == true) then
+  			open(File.join(@productDSLRoot,"#{@libtype}/#{args[2]}.oil")) {|f| @contents = f.read }
+  		else
+  			open(File.join(@productDSLRoot,"/#{args[0]}.oil")) {|f| @contents = f.read }
+  		end
+    	dsl = @contents.to_s
+    	# todo: bit clumsy but need it working
+    	if (@useDynamicFileMapping == true) then
+    		frag = VPMSComponentSchemaInterpreter.execute(dsl,@useDynamicFileMapping)
+    	else
+    		frag = VPMSComponentSchemaInterpreter.execute(dsl)
+    	end
+    	@schemaFragments << applyTransform(frag)
+  end
+  
+end