iab-Oil 0.1.2

data/lib/CollesceProductInterpreter.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__),'DSLContext')
+
+#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 CollesceProductInterpreter < DslContext
+
+  bubble :than, :is, :list, :the, :to, :at, :it, :end
+    
+  def getResult
+    result = Array.new
+    result[0] = @entities
+    result[1] = @coverages
+    result
+  end
+  
+  def product(*args)
+    @entities = Hash.new
+    @coverages = Hash.new
+  end
+  
+  def endproduct
+  end
+  
+  def entities(*args)
+    @libtype = "entities"
+  end
+  
+  def endentities    
+  end
+  
+  def coverages(*args)
+    @libtype = "coverages"
+  end
+  
+  def endcoverages    
+  end
+  
+  def has_one(*args)
+    @entities[args[0]] = "has_one" if @libtype == "entities"
+    @coverages[args[0]] = "has_one" if @libtype == "coverages"
+  end
+  
+  def has_many(*args)
+  end
+end

data/lib/CoverageInterpreter.rb

@@ -0,0 +1,161 @@
+require 'set'
+require File.join(File.dirname(__FILE__),'DSLContext')
+
+#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 CoverageInterpreter < DslContext
+
+  bubble :than, :is, :list, :the, :to, :at, :it, :end
+  
+  def initialize(*args)
+    @columns = 1
+    @hidden_fields = Set.new
+  end
+  
+  def getResult
+    widgets = ""
+    @widgets.each { |k| widgets << ",'#{k}'" }
+    @erb = "<%= widgets(#{widgets[1..-1]}) %>\n" + @erb unless widgets.length == 0
+    @erb
+  end
+
+  def hideFields(*args)
+    args[0].split('&').each { |a| @hidden_fields << a.to_sym }
+  end
+
+  def columns(*args)
+    @columns = args[0].to_i
+  end
+ 
+  def coverage(*args)
+    begin_erb(COVERAGE_DEF_ROOT, args)
+  end
+
+  def endcoverage(*args)
+    end_erb
+  end
+  
+  def entity(*args)
+    begin_erb(ENTITY_DEF_ROOT, args)   
+  end
+
+  def endentity(*args)
+    end_erb
+  end
+  
+  def use(*args)
+    #the test on hidden_fields property is a bit too brutal in that it cuts out a whole part of the tree
+    #it serves to provide the same hiding capability as we had in the iteration earlier this day
+    #but more consideration especially around individual field level restriction needs to be considered
+    #i.e. we may want to keep part of the tree but loose some of the fields at that level
+    #so that we need considering in the code block below 
+    args.each { |a| return if @hidden_fields.include?(a.to_sym) unless a.class.name == 'Hash' }
+
+    # If the last argument is a hash we assume it's a hash of overrides which we remove
+    # and merge in later.
+    args_hash = nil
+    args_hash = args.pop if args.last.class.name == 'Hash'
+    
+    #now figure out whether the last arg above leads to an empty hash
+    #not strictly empty since every hash has an xpath property of the position in the class hierarchy
+    #if so backup a level and read the property whose name = the last arg value passed in
+    lastArg = ""
+    specificProperty = false
+    myHash = @prdhash["#{@argName}#{args}"]
+    raise "Failed to find [#{@argName}#{args}] in [#{@argName}PropertyHash]" if myHash == nil
+    
+    # Have a look for meta data pertaining to the class which may specify a type.
+    class_meta_data = @prdhash["#{@argName}#{args}MD"]
+    specific_widget = class_meta_data[:type] unless class_meta_data == nil
+    
+    if (myHash.length == 1)
+      specificProperty = true
+      lastArg = args.pop
+      myHash = @prdhash["#{@argName}#{args}"]
+      # Since we are delegating to our parent definition we look at that for a type
+      # specification if we haven' already found one.
+      #class_meta_data = @prdhash["#{@argName}#{args}MD"] if specific_widget == nil
+      #specific_widget = class_meta_data[:type] unless class_meta_data == nil
+    end
+    
+    @widgets << specific_widget unless specific_widget == nil    
+    @erb << "<% #{specific_widget} \"#\{widgetROOT}/#{specific_widget}\" do %>" unless specific_widget == nil
+   
+    myHash.each do |property, value|
+      if (property != 'xpath' and (property =~ /MD$/) == nil) then
+        #properties of type HashWithIndifferentAccess hold metadata about the property
+        if (value == "" && (!specificProperty || (specificProperty && property == "#{lastArg}"))) then
+
+          if (@columns > 1)
+            @erb << '<tr>' if @col == 1
+            @erb << "<td width=\"#{100/@columns}%\">"
+            #@erb << "<div style=\"display: inline-block;float: left;width: #{(100/@columns)}%;\">"
+          end
+          
+          metaData = myHash["#{property}MD"]
+          metaData = metaData.merge(args_hash) unless args_hash == nil
+          sMetaData = "{"        
+          metaData.each { |n, v| sMetaData << "'#{n}' => '#{v}'," }
+          sMetaData << ":entityName => '#{@argName}#{args}',"
+          sMetaData << ":propertyName => '#{property}'"
+          sMetaData << "}"         
+          #puts "METADATA:#{property}:#{metaData['mask']}_input:#{metaData['type']}_input"
+          @erb << "<% singleline_rowpanel \"#\{widgetROOT}/singleline_rowpanel\",\"#{sMetaData}\"  do %>\n"
+          @widgets << "singleline_rowpanel"
+          
+          if (metaData['type'] != nil) then
+            @widgets << "#{metaData['type']}_input"
+            @erb << "<% #{metaData['type']}_input \"#\{widgetROOT}/#{metaData['type']}_input\",\"#{sMetaData}\"  do %>\n<% end %>"
+          elsif (metaData['mask'] != nil) then
+            @widgets << "#{metaData['mask']}_input"
+            @erb << "<% #{metaData['mask']}_input \"#\{widgetROOT}/#{metaData['mask']}_input\",\"#{sMetaData}\"  do %>\n<% end %>"
+          else
+            @widgets << "text_input"
+            @erb << "<% text_input \"#\{widgetROOT}/text_input\",\"#{sMetaData}\"  do %>\n<% end %>"
+          end
+
+          @erb << "\n<% end %>"
+          
+          if (@columns > 1)
+            #@erb << '</div>'
+            @erb << '</td>'
+            @erb << '</tr>' if @col == @columns
+            @col = 0 if @col == @columns
+            @col += 1
+          end
+        end
+      end
+    end    
+    @erb << '<% end %>' unless specific_widget == nil    
+  end
+   
+  private
+  def begin_erb(dsl_root, *args)
+    @widgets = Set.new
+    @col = 1
+    @argName = "#{args[0]}"     
+    @prdhash = YAML::load(open(File.join(dsl_root,"/#{@argName}PropertyHash"),'r' ))
+    # Check to see if there's meta data specifying a type for this class.
+    class_meta_data = @prdhash["#{@argName}MD"]
+    specific_widget = class_meta_data[:type] unless class_meta_data == nil
+    @widgets << specific_widget unless specific_widget == nil
+    @erb = ''
+    @erb = "<% #{specific_widget} \"#\{widgetROOT}/#{specific_widget}\" do %>" unless specific_widget == nil
+    @erb << '<table width="100%">' if @columns > 1
+  end
+  
+  private
+  def end_erb()    
+    if(@columns > 1)
+      @erb << '</tr>' if @erb.match(/tr>$/) == nil
+      @erb << '</table>'
+    end
+    class_meta_data = @prdhash["#{@argName}MD"]
+    specific_widget = class_meta_data[:type] unless class_meta_data == nil
+    @erb << '<% end %>' unless specific_widget == nil
+  end  
+end
+

data/lib/CoverageInterpreter2.rb

@@ -0,0 +1,36 @@
+require 'DSLContext'
+
+class CoverageInterpreter2 < DslContext
+  def initialize
+    @name = ''
+    @entity = Array.new
+  end
+  
+  def getResult
+    @entity
+  end
+ 
+  def coverage(*args)
+    @name = args[0].to_s
+  end
+
+  def endcoverage(*args)
+    #nothing to do here at the mo
+  end
+  
+  def entity(*args)
+    coverage(args)
+  end
+
+  def endentity(*args)
+    endcoverage(args)
+  end
+  
+  def use(*args)
+    # remove the trailing defaults and stuff
+    if(args.last.class.name == 'Hash')
+      args.pop
+    end
+    @entity << args.collect{ |p| ':' + (p.to_s()) }.join(',')
+  end
+end

data/lib/DSLContext.rb

@@ -0,0 +1,28 @@
+class DslContext
+  def self.execute(*args)
+    rules = polish_text(args[0])
+	#significant change to allow class instance variables to be set on the initialize, ahead
+	#of the evaluation of the DSL - allows dynamic props to be sent to the class
+	#see VPMSProductSchemaInterpreter, which gets a param from the package interpreter
+    inst = (args.length > 1) ? self.new(args.slice(1,1)) : self.new
+    rules.each do |rule|
+      result = inst.instance_eval(rule)
+      #passes results as parm into code that was passed with call to execute (if any was)
+      yield result if block_given?
+    end
+    inst.getResult
+  end
+
+  def self.polish_text(text)
+    rules = text.split("\n")
+    rules.collect do |rule|
+      rule << " "
+    end
+  end
+  
+  def self.bubble(*methods)
+    methods.each do |method|
+      define_method(method) {}
+    end
+  end
+end 

data/lib/DataModelInterpreter.rb

@@ -0,0 +1,109 @@
+require 'set'
+require File.join(File.dirname(__FILE__),'DSLContext')
+require 'Element'
+
+class DataModelInterpreter < DslContext
+  def initialize
+    @elements = []
+    @elementTree = []
+    @depth=0
+  end
+
+  def getResult
+    #dumpParsedStructure
+    result = @elements
+    result
+  end
+  # --parse - implement the grammar
+  def datamodel(*args)
+  end
+
+  def enddatamodel(*args)
+  end
+
+  def createNewElement(name,coverage,parent,type)
+    e = ElementFactory(name,coverage,parent,type)
+    @elementTree.last.children.push e if @elementTree.last and @elementTree.length > 0
+    @elementTree.push e
+  end
+
+  def ElementFactory(name,coverage,parent,type)
+    @elements.each do |node|
+      if node.name == name
+        node.parent = parent
+        return node
+      end
+    end
+    e = Element.new(name,coverage,parent,type)
+    @elements.push e
+    return e
+  end
+
+  def element(*args)
+    createNewElement(args[0],false,@elementTree.last,nil)
+  end
+
+  def endelement(*args)
+    @elementTree.pop
+  end
+
+  def coverage(*args)
+    createNewElement(args[0]+ "Coverage",true,@elementTree.last,"coverages")
+  end
+
+  def endcoverage(*args)
+    @elementTree.pop
+  end
+
+  def entity(*args)
+    createNewElement(args[0],true,@elementTree.last,"entities")
+  end
+
+  def endentity(*args)
+    @elementTree.pop
+  end
+
+  def field(*args)
+    if (args[0][:ctype] != nil)
+      if (@elementTree.last.coverage)
+        parent = nil
+      else
+        parent = @elementTree.last
+      end
+      createNewElement(args[0][:ctype],false,parent,nil) #the parent is nil here since a complex type may be used by many coverages or entities
+       @elementTree.pop
+    else
+      @elementTree.last.fields.push args[0]
+    end
+  end
+
+  #----------- dump
+
+  def dumpParsedStructure
+    @dumpStructure = ""
+    @elements.each do |e|
+      if (e.coverage)
+        @dumpStructure << "#{e.name}:\n"
+        listChildren(e)
+        @dumpStructure << "\n"
+      end
+    end
+    puts "#{@dumpStructure}"
+  end
+
+  def listChildren(e)
+     @depth = @depth + 1
+     e.children.each do |c|
+      str = ""
+      @depth.times { str << "\t"}
+      @dumpStructure << "#{str}#{c.name}\n"
+      c.fields.each do |f|
+         str = ""
+         @depth.times { str << "\t\t"}
+         @dumpStructure << "#{str}field:#{f}\n"
+      end
+      listChildren(c)
+      @depth = @depth - 1
+    end
+  end
+end

data/lib/Element.rb

@@ -0,0 +1,12 @@
+class Element
+  attr_accessor :coverage,:name,:children,:parent,:fields,:type
+
+  def initialize(name,isaentityorcoverage,parent,type)
+    @coverage = isaentityorcoverage
+    @name = name
+    @children = []
+    @parent = parent
+    @fields = []
+    @type = type
+  end
+end

data/lib/LayoutInterpreter.rb

@@ -0,0 +1,166 @@
+require File.join(File.dirname(__FILE__),'DSLContext')
+require File.join(File.dirname(__FILE__),'CoverageInterpreter')
+
+class LayoutInterpreter < DslContext
+
+  bubble :than, :is, :list, :the, :to, :at, :it, :endheader, :endlayout, :endfooter
+  
+  def getResult
+    widgets = ""
+    @widgets.each do |k,v|
+      widgets << ",'#{k}'"
+    end
+    @erb = "<%= widgets(#{widgets[1..-1]}) %>\n" + @erb unless widgets.length == 0
+    @erb
+  end
+  
+  def product(*args)
+    @product = args[0]
+  end
+
+  def navigation(steps)
+    @navigationSteps = steps
+  end
+  
+  def layout(*args)
+    @widgets = Hash.new
+    @erb = "<head>\n"
+    @erb << "<%= getCSS('#{args[0]}.css') %>\n"
+    @erb << "</head>\n"
+    @erb << "<body>\n"
+    @erb << "\t<div class=\"container\">\n"
+  end
+
+  def endlayout(*args)
+    @erb << "\t</div>\n"
+    @erb << "</body>"
+  end
+  
+  def header(*args)
+    @erb << "\t\t<div class=\"header\">\n"
+  end
+  
+  def endheader(*args)
+    @erb << "\t\t</div>\n"
+  end
+
+  def miniheader(*args)
+    @erb << "\t\t<div class=\"mini-header\">#{args[0]}\n"
+  end
+  
+  def endminiheader(*args)
+    @erb << "\t\t</div>\n"
+  end
+
+  def column(*args)
+    @erb << "\t\t<td style=\"vertical-align: top;\">\n"
+  end
+  
+  def endcolumn
+    @erb << "\t\t</td>\n"
+  end
+  
+  def columns
+    @erb << "\t\t<table class=\"columnWrapper\"><tr>\n"
+  end
+
+  def endcolumns
+    @erb << "\t\t</tr></table>\n"
+  end
+  
+  def footer(*args)
+    @erb << "\t\t<div class=\"footer\">\n"
+  end
+  
+  def endfooter(*args)
+    @erb << "\t\t</div>\n"
+  end
+
+  def panel(*args)
+    if args.length > 0
+      @erb << "\t\t\t<div class=\"#{args[0]}\">\n"
+    else
+      @erb << "\t\t\t<div>\n"
+    end
+  end
+
+  def endpanel
+    @erb << "\t\t\t</div>\n"
+  end
+  
+  def product_menu(*args)
+    #TODO:slidingMenu needs implementing as a single item menu construct
+    #that is repeated for each of theargs
+    @erb << "\t\t\t"
+    @erb << '<%= render :partial => "#{widgetROOT}/sliding_menu/sliding_menu", :locals => { :menuitems => %w('
+    @erb << args.join(' ')
+    @erb << ') } %>'
+    @erb << "\n"
+  end
+  
+  def teaser(*args)
+    @erb << "\t\t\t<%= render :partial => \"#\{teaserROOT}/#{args[0]}\" %>\n"
+  end
+  
+  def widget(*args)
+    @widgets["#{args[0]}"] = 1
+
+    @erb << "\t\t\t<% #{args[0]} \"#\{widgetROOT}/#{args[0]}\""
+    
+    widget_args_hash = args[1]
+    
+    if (@navigationSteps.length > 0)
+      if (args[0].to_sym == :submit_panel)
+        widget_args_hash = {:nextLayout => @navigationSteps[0].to_sym}
+      elsif (args[0].to_sym == :button_panel)
+        str = "{:button1 => :#{@navigationSteps.first}"
+        i = 1
+        @navigationSteps.each do |step|
+          str << ",:button#{i += 1} => :#{step}" unless step == @navigationSteps.first
+        end
+        str << "}"
+        widget_args_hash = eval(str)
+      end
+    end
+    
+    
+    if (widget_args_hash and widget_args_hash.class.name == "Hash")
+      sHash = "{"
+      comma = ""
+      widget_args_hash.each do |n,v|
+        sHash << "#{comma}:#{n} => '#{v}'"
+        comma = ","
+      end
+      sHash << "}"  
+
+      @erb << ",\"#{sHash}\" do %>\n"
+    else
+      @erb << " do %>\n"
+    end
+  end
+  
+  def endwidget
+    @erb << "\t\t\t <% end %>\n"
+  end
+  
+  def entity(*args)
+    interpret(ENTITY_DSL_ROOT, *args)
+  end
+  
+  def coverage(*args)
+    interpret(COVERAGE_DSL_ROOT, *args)
+  end
+  
+  private
+  def interpret(dslroot, *args)
+    path = dslroot.gsub(/%product/,@product)
+    open(File.join(path,"/#{args[0]}.oil")) {|f| @contents = f.read }
+    dsl = ''
+    if (args[1])
+      dsl << "hideFields \"#{args[1][:hide]}\"\n" if args[1][:hide]
+      dsl << "columns \"#{args[1][:columns]}\"\n" if args[1][:columns]
+    end
+    dsl << @contents.to_s
+    @erb << CoverageInterpreter.execute(dsl, args[1])
+  end
+end

data/lib/ProductInterpreter2.rb

@@ -0,0 +1,51 @@
+require 'DSLContext'
+
+class ProductInterpreter2 < DslContext
+
+  attr_reader :entity
+  attr_reader :coverage
+  
+  def initialize
+    @name = ''
+    @entity = Array.new
+    @coverage = Array.new
+  end
+  
+  def getResult
+    self
+  end
+  
+  def product(*args)
+    @name = args[0]
+  end
+  
+  def endproduct(*args)
+    
+  end
+ 
+  def coverages(*args)
+    @currentGroup = @coverage
+  end
+
+  def endcoverages(*args)
+  end
+  
+  def entities(*args)
+    @currentGroup = @entity
+  end
+
+  def endentities(*args)
+  end
+  
+  def has_one(*args)
+    @currentGroup.push([args[0].to_s(), 'has_one'])
+  end
+  
+  def has_many(*args)
+    @currentGroup.push([args[0].to_s(), 'has_many'])
+  end
+  
+  def has_between(*args)
+    @currentGroup.push([args[0].to_s(), 'has_many'])
+  end
+end

data/lib/RailsProcessInterpreter.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__),'DSLContext')
+
+#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 RailsProcessInterpreter < DslContext
+
+  bubble :channels,:channel,:processes,:process,:to,:endprocess,:endprocesses,:endchannel,:endchannels
+
+  def getResult
+    @result
+  end
+
+  def workflow_steps
+    @result = ""
+  end
+  
+  def endworkflow_steps
+  end
+
+  def flow(*args)
+    #serialize array
+    sarray ="["
+    args[1].each do |a|
+      if (a == args[1].first)
+        sarray << ":#{a}"
+      else
+        sarray << ",:#{a}"
+      end
+    end
+    sarray << "]"
+    @result << ":#{args[0]} => #{sarray},"
+  end
+
+  def valid_flows(*args)
+    @result << "def wireProcess\n"
+    @result << "@processMap = {"
+  end
+
+  def endvalid_flows(*args)
+    @result << "}\n"
+    @result << "end"
+  end
+  
+  def step(*args)
+    #there will be at least five parameters for an IAB app - rails controller, rails action, language, brand, product
+    controller_process_step = "if self.respond_to?(:#{args[1][:do].to_s.downcase})\nparams.merge!(#{args[1][:do].to_s.downcase})\nend" if (args[1][:do])
+    engine_call = ""
+    engine_call << "@results = Communicator.instance.handle(session,\"#{args[1][:do]}\",params)" if (args[1][:do])
+    marshalling = ""
+    marshalling << "possible_redirect = massage(@results) if @results\nif possible_redirect\nredirect_to possible_redirect\nreturn\nend" if (args[1][:do])
+    injectLayoutDict = "introduce_layout_dictionary(\"#{args[1][:template]}\")"
+    
+    action = "def #{args[0]}\n@template.setParmsForViewUse({:currentstep => :#{args[0]}})\n#{controller_process_step}\n#{engine_call}\n#{marshalling}\n#{injectLayoutDict}\nrender :template => \"#{args[1][:template]}.oil\", :layout => \"#{args[1][:layout]}\"\nend\n" 
+    #puts("introducing controller action\n#{action}")
+    @result << action
+  end
+end