iab-FinancialProductBuilder 0.1.3

data/lib/controllers/pbbase_controller.rb

@@ -0,0 +1,155 @@
+# Copyright (c) 2007-2009 Orangery Technology Limited
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+require 'Marshaller'
+require 'helpers/pb_helper'
+
+class PbBaseController < ApplicationController
+  
+  include Marshaller
+  include PbHelper
+  
+  def products
+    product = params['product']
+    if (product != nil) then
+      if (!product?(product)) then
+        session[:selected_product] = nil
+        session[:selected_product_item] = nil
+      else
+        session[:selected_product] = product
+        session[:selected_product_item] = nil
+      end
+    end
+    entity = params['entity']
+    if (entity != nil) then
+      session[:selected_product_item] = entity
+    end
+    render(:template => "pb/products", :layout => 'products')
+  end
+  
+  def product_add
+    name = params['name']
+    unless (name == nil) then
+      name.strip!()
+      name.capitalize!()
+      addProduct(name)
+      session[:selected_product] = name
+      session[:selected_product_item] = nil
+    end
+    redirect_to(:action => 'products')
+  end
+  
+  def product_clone
+    existingName = session[:selected_product]
+    clonedName = params['clonedName']
+    unless ((existingName == nil) || (clonedName == nil) || (clonedName.empty?())) then
+      clonedName.strip!()
+      clonedName = Inflector.camelize(clonedName)
+      cloneProduct(existingName, clonedName)
+      session[:selected_product] = clonedName
+      session[:selected_product_item] = nil
+    end
+    redirect_to(:action => 'products')
+  end
+  
+  def product_delete
+    name = session[:selected_product]
+    unless (name == nil) then
+      deleteProduct(name)
+      session[:selected_product] = nil
+      session[:selected_product_item] = nil
+    end
+    redirect_to(:action => 'products')
+  end
+  
+  def entity_add
+    name = params['name']
+    if (params['type'] == 'coverage') then
+      type = :coverage
+    else
+      type = :entity
+    end
+    unless (name == nil) then
+      addProductEntity(session[:selected_product], type, name)
+    end
+    render(:text => :OK)
+  end
+  
+  def update_cardinality
+    entity = params['entity']
+    cardinality = params['cardinality']
+    unless ((entity == nil) || (cardinality == nil)) then
+      updateEntityCardinality(session[:selected_product], entity, cardinality)
+    end
+    render(:text => :OK)
+  end
+
+  def entity_delete
+    name = params['name']
+    unless (name == nil) then
+      deleteProductEntity(session[:selected_product], name)
+      if (session[:selected_product_item] == name) then
+        session[:selected_product_item] = nil
+      end
+    end
+    render(:text => :OK)
+  end
+    
+  def entity_save
+    entities = params['entities']
+    unless (entities == nil) then
+      selected = entities.split(' ');
+      saveEntityDetails(session[:selected_product], session[:selected_product_item], selected.sort)
+    end    
+    render(:text => :OK)
+  end
+
+  def dictionary_update
+    lang = session[:lang]
+    id = params['id']
+    value = params['value']
+    if ((lang != nil) && (id != nil)) then
+      updateDictionary(lang, id, value)
+    end
+    # render back the value to confirm change
+    render(:text => value)
+  end
+  
+  def test_drive
+    # extract data from incoming params
+    lang = params['lang']
+    brand = params['brand']
+    product = params['product']
+    # the following config could be externalised if required
+    port = '9000'
+    edit = 'true'
+    environment = 'development'
+    logDir = 'log'
+    pidFile = File.join(logDir, 'testdrive.pid')
+    logFile = File.join(logDir, 'testdrive.log')
+    if (File.exist?(logFile)) then
+      FileUtils.rm(logFile)
+    end
+    # stop existing mongrel if there is one
+    startCmd = "source ~/.bash_profile;mongrel_rails start  --daemonize --port #{port} --environment #{environment} --log #{logFile} --pid #{pidFile}"
+    stopCmd = "mongrel_rails stop --pid #{pidFile}"
+    restartCmd = "mongrel_rails restart --pid #{pidFile}"
+    if (File.exist?(pidFile)) then
+      cmd = restartCmd
+    else
+     cmd = startCmd
+    end
+    system(cmd)
+    sleep(1)
+    puts "Executed Mongrel command [#{cmd}] see log file [#{logFile}] for further details\n"
+    # send back the url for test driving
+    url = "http://127.0.0.1:#{port}/iab/QNBRiskDataCollect?brand=#{brand}&product=#{product}&lang=#{lang}&edit=#{edit}"
+    puts "Returned URL for test drive [#{url}]"
+    render(:text => url)
+  end
+
+  def update_mandatory
+    puts 'PLEASE WRITE ME'
+    render(:text => :OK)
+  end
+end

data/lib/deriveDSL.rb

@@ -0,0 +1,147 @@
+#!/usr/local/bin/ruby -w
+
+# == Copyright
+#
+#   Copyright (c) 2007-2009 Orangery Technology Limited
+#   Licensed under the same terms as Ruby.
+#
+# == Synopsis
+# 
+# A script to call high level DSL interpreters and create an IAB compliant
+# repository of product level DSL from an enterprise data and process DSL model
+# of the business.
+# 
+# In short this offers an easy way to quickly bootsrap an insurance business
+# by defining products, their data models and their processes.
+#
+# == Usage
+# 
+#   ./deriveDSL.rb 'input path' 'output path' OrgName DataModel.oil SiteProcess.oil
+#   
+
+require 'rubygems'
+require 'DataModelInterpreter'
+require 'SiteProcessInterpreter'
+require 'Element'
+
+require 'models'
+require 'processmap'
+require 'productconfig'
+
+require 'genGITstructure'
+require 'rdoc/usage'
+
+if (ARGV.length != 5)
+  RDoc::usage
+end
+
+INPUT = ARGV[0]
+OUTPUT = ARGV[1]
+ORG = ARGV[2]
+DM = ARGV[3]
+SP = ARGV[4]
+
+contents = ""
+open("#{INPUT}/#{SP}") {|f| contents = f.read }
+hoo = SiteProcessInterpreter.execute(contents.to_s) #hoo is an array of objects
+# the array contains three child objects:-
+# 0) distinct list of steps with associated navigation points, a "do" statement (if any) (a hash)
+# 1) distinct list of products (an array)
+# 2) distinct list of data items (a set)
+
+tree = GenGITStructure.new
+tree.makeDirTree(OUTPUT,ORG,hoo[1])
+
+open("#{INPUT}/#{DM}") {|f| @contents = f.read }
+dsl = @contents.to_s
+elements = DataModelInterpreter.execute(dsl) #elements is an array of 'Element' objects
+
+# Element structure is:-
+# isacoverage? - indicates whether top level - really should be named 'top level coverage or entity?'
+# name - name
+# children - array elements
+# parent - an element
+# fields - name, type, mask
+# type - coverage or entity
+
+modelData = Models.new
+resultDMFiles = modelData.generateFiles(elements)
+dictionaryEntries = modelData.genDict(elements)
+
+# create 'the library'
+# these are coverage and entity definitions in a RAILS format
+# exactly the same format as RAILS would generate from a relational schema
+# in .../libraries/coverages
+# in .../libraries/entities
+resultDMFiles.each do |k,v|
+  File.open(File.join(OUTPUT, ORG,'git','libraries',"#{v[3]}","#{k}DataModel.rb"), 'w') {|f| f.write(v[0]) }
+  File.open(File.join(OUTPUT, ORG,'git','libraries',"#{v[3]}","#{k}NodeName.rb"), 'w') {|f| f.write(v[1]) }
+  File.open(File.join(OUTPUT, ORG,'git','libraries',"#{v[3]}","#{k}PropertyHash"), 'w') {|f| f.write(v[2]) }
+end
+
+# create the product process DSL file - git/products/PRODUCT/DSL/processes.oil
+# use hoo[0] to drive this
+pmap = ProcessMap.new
+map = pmap.generateMap(hoo[0])
+File.open(File.join(OUTPUT, ORG,'git','products',"#{hoo[1]}",'DSL','processes.oil'), 'w') {|f| f.write(map) }
+
+# create layouts for each of the steps of each process
+# generate to git/products/PRODUCT/DSL/layouts
+# drive this from hoo[0] data since this contains steps and data usage info
+layouts = pmap.genLayouts(hoo[0],elements)
+layouts.each do |l|
+   File.open(File.join(OUTPUT, ORG,'git','products',"#{hoo[1]}",'DSL','layouts',"#{l[0]}.oil"), 'w') {|f| f.write(l[1]) }
+end
+
+# create product level manifest of coverages and entities - git/products/PRODUCT/DSL/product.oil
+# for now use hoo[2] to drive this
+pcfg = ProductConfig.new
+cfg = pcfg.createManifest(hoo[1],elements)
+File.open(File.join(OUTPUT, ORG,'git','products',"#{hoo[1]}",'DSL','product.oil'), 'w') {|f| f.write(cfg) }
+
+# create product level entities and coverages field usage files...essentially 'views' on the coverage record
+# generate to git/products/PRODUCT/DSL/coverages (or /entities)
+# use hoo[2] and field info from the elements object returned from DataModelInterpreter
+entcov = pcfg.genViews(elements)
+entcov[0].each do |fd|
+  File.open(File.join(OUTPUT, ORG,'git','products',"#{hoo[1]}",'DSL','coverages',"#{fd[0]}.oil"), 'w') {|f| f.write(fd[1]) }
+end
+entcov[1].each do |fd|
+  File.open(File.join(OUTPUT, ORG,'git','products',"#{hoo[1]}",'DSL','entities',"#{fd[0]}.oil"), 'w') {|f| f.write(fd[1]) }
+end
+
+# create git/products/PRODUCT/DSL/rating.oil file by simply writing out 2 hardcoded lines for the moment
+rating = ""
+rating << "dictionary 'XML','ShopPackageQuoteNBRq','110','100','ShopSkel100-01'\n"
+rating << "rating_engine 'RTE','Response'"
+File.open(File.join(OUTPUT, ORG,'git','products',"#{hoo[1]}",'DSL','rating.oil'), 'w') {|f| f.write(rating) }
+
+
+# copy layout grids from lib/templates_and_resources/layouts_and_grids
+# to git/libraries/genericlayoutgrids
+pcfg.copyDirectoryWithoutHiddenRecursively(File.join('templates_and_resources','layouts_and_grids'),File.join(OUTPUT, ORG,'git','libraries','genericlayoutgrids','stylesheets'))
+
+# copy lib/templates_and_resources/defaultBrand contents
+# to git/brands/default
+pcfg.copyDirectoryWithoutHiddenRecursively(File.join('templates_and_resources','defaultBrand'),File.join(OUTPUT, ORG,'git','brands','Default'))
+
+pcfg.copyDirectoryWithoutHiddenRecursively(File.join('templates_and_resources','DSLTemplates'),File.join(OUTPUT, ORG,'git','libraries','DSLTemplates'))
+
+# create dictionary file and place in git/products
+# take dictionary template from lib/templates_and_resources/dictionary_en.rb
+# and splice in data model specific strings by replacing string #ENTITYSPECIFIC
+# use xpath to derive string name and use node name as the translation target
+pcfg.copyDirectoryWithoutHiddenRecursively(File.join('templates_and_resources','dictionaries'),File.join(OUTPUT, ORG,'git','products'))
+open(File.join(OUTPUT, ORG,'git','products','dictionary_en.rb'), 'r+') do |f|
+  content = f.read()
+  content.gsub!('#ENTITYSPECIFIC',dictionaryEntries)
+  f.truncate(0)
+  f.rewind()
+  f.write(content)
+  f.close()
+end
+
+# copy example list file into git/libraries/lists from lib/templates_and_resources/lists/PersonTitles_en.rb
+# to git/libraries/lists/PersonTitles_en.rb
+pcfg.copyDirectoryWithoutHiddenRecursively(File.join('templates_and_resources','lists'),File.join(OUTPUT, ORG,'git','libraries','lists'))
+

data/lib/genGITstructure.rb

@@ -0,0 +1,31 @@
+require 'fileutils'
+
+include FileUtils
+
+class GenGITStructure
+  def makeDirTree(*args)
+    output = args[0]
+    org = args[1]
+    productNames = args[2]
+
+    dir = ""
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','brands'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','libraries'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','libraries','coverages'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','libraries','entities'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','libraries','genericlayoutgrids'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','libraries','genericlayoutgrids','stylesheets'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','libraries','lists'))
+    Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','products'))
+
+    productNames.each do |p|
+      Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','products',"#{p}"))
+      Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','products',"#{p}",'DSL'))
+      Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','products',"#{p}",'DSL','coverages'))
+      Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','products',"#{p}",'DSL','entities'))
+      Dir.mkdir(dir) if !File.exist?(dir = File.join(output, org,'git','products',"#{p}",'DSL','layouts'))
+    end
+  end
+end

data/lib/helpers/pb_helper.rb

@@ -0,0 +1,352 @@
+# Copyright (c) 2007-2009 Orangery Technology Limited
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+require 'fileutils'
+require 'ProductInterpreter'
+require 'CoverageInterpreter2'
+require 'ProductInterpreter2'
+require 'channel_manager'
+
+module PbHelper
+
+  include FileUtils
+  include ChannelManager
+
+  def product?(name)
+    if ((name != nil) && (!name.empty?()) && File.directory?(File.join(PRODUCTS_ROOT, name))) then
+      # TODO: add code here to perform a validation of the product
+      # Possible steps:
+      # 1. Check there is a product.oil
+      # 2. Check that each entity and coverage in product.oil has a valid entity/coverage oil file
+      # 3. Ensure all items are in the library etc.
+      # .... loads of other stuff
+      return true
+    end
+    return false
+  end
+
+  def getProducts
+    products = Array.new
+    Dir.glob(File.join(PRODUCTS_ROOT, '*'), File::FNM_PATHNAME) do |p|
+      if File.directory?(p)
+        products.push(File.basename(p))
+      end
+    end
+    products.sort
+  end
+  
+  def getLanguages
+    languages = Array.new
+    Dir.glob(File.join(PRODUCTS_ROOT, 'dictionary_*.rb'), File::FNM_PATHNAME) do |p|
+      languages.push(File.basename(p).sub(/dictionary_(.\w+)\.rb/, '\1'))
+    end
+    languages.sort
+  end
+  
+  def getBrands
+    brands = Array.new
+    Dir.glob(File.join(BRANDS_ROOT, '*'), File::FNM_PATHNAME) do |p|
+      if File.directory?(p)
+        brands.push(File.basename(p))
+      end
+    end
+    brands.sort
+  end
+  
+  def addProduct(name)
+    productDirectory = File.join(PRODUCTS_ROOT, name)
+    # create the new product directory
+    Dir.mkdir(productDirectory)
+    # create the DSL folder
+    productDSLDirectory = File.join(productDirectory, 'DSL')
+    Dir.mkdir(productDSLDirectory)
+    # copy the DSL template directory
+    copyDirectoryWithoutHiddenRecursively(PRODUCT_DSL_TEMPLATE_ROOT, productDSLDirectory)
+    # update product.oil to put in the produt name
+    findAndReplaceInFile(File.join(productDirectory, 'DSL', 'product.oil'), /#\$PRODUCT_NAME\$/, name)
+  end
+  
+  def cloneProduct(existingProductName, newProductName)
+    existingProductDirectory = File.join(PRODUCTS_ROOT, existingProductName)
+    newProductDirectory = File.join(PRODUCTS_ROOT, newProductName)
+    # copy the product in its entirety
+    copyDirectoryWithoutHiddenRecursively(existingProductDirectory, newProductDirectory)
+    # update the main oil files
+    findAndReplaceInFile(File.join(newProductDirectory, 'DSL', 'product.oil'), /(\s+:)#{existingProductName}/, "\\1#{newProductName}")
+  end
+  
+  def deleteProduct(name)
+    FileUtils.mv(File.join(PRODUCTS_ROOT, name), File.join(PRODUCTS_ROOT, '.' + name))
+  end
+  
+  def getProductEntities(product, type)
+    open(File.join(PRODUCTS_ROOT, product, 'DSL','product.oil')) do |f|
+      product = ProductInterpreter2.execute(f.read())
+      f.close()
+    end
+    product.method(type).call().sort()
+  end
+ 
+  def addProductEntity(product, type, name)
+    # add the coverage to product.oil
+    # and ...
+    # create the new coverage oil file
+    if (type == :coverage) then
+      findAndReplaceInFile(File.join(PRODUCTS_ROOT, product, 'DSL', 'product.oil'), /(\s+endcoverages)/, "\n   has_one :#{name}\\1")
+      f = File.new(File.join(PRODUCTS_ROOT, product, 'DSL', 'coverages', name + '.oil'), 'w+')
+      regex = /(\s+#\$COVERAGES\$)/
+    else
+      findAndReplaceInFile(File.join(PRODUCTS_ROOT, product, 'DSL', 'product.oil'), /(\s+endentities)/, "\n   has_one :#{name}\\1")
+      f = File.new(File.join(PRODUCTS_ROOT, product, 'DSL', 'entities', name + '.oil'), 'w+')
+      regex = /(\s+#\$ENTITIES\$)/
+    end
+    # some coverages and entities are essential, lets find them now
+    recommendedSelections = getDefaultSelections(name, type, nil, nil)
+    f.chmod(0644)
+    oil = <<OIL
+#{type} :#{name}
+#{recommendedSelections}
+end#{type}
+OIL
+    f.write(oil);
+    f.close()
+    # scan the layout oils and add this entity/coverage if required in the markup
+    Dir.glob(File.join(PRODUCTS_ROOT, product, 'DSL', 'layouts', '*.oil')) do |lf|
+      findAndReplaceInFile(lf, regex, "\n                #{type} :#{name}\\1")
+    end
+  end
+
+  def getDefaultSelections(entity, type, recommendedSelections, path)
+    if (recommendedSelections == nil) then
+      recommendedSelections = ''
+      loadLibraryEntity(entity, type)
+      @hash = getPropertyHash(type, entity)
+      path = Array.new
+      path.push(entity)
+    else
+      path.push(entity.sub(/#{path.join()}/, ''))
+    end
+    c = eval(entity)
+    associations = c.reflect_on_all_associations()
+    associations.each do |a|
+      className = a.name.id2name
+      klass = eval(className)
+      # see if this entity is defined as essential in the property hash
+      sectionName = "#{className}MD"
+      section = @hash[sectionName]
+      if (section != nil) then
+        value = @hash[sectionName]['usebydefault']
+      end
+      # puts "Entity [#{className}] value [#{value}]\n"
+      if (value == 'true') then
+        recommendedSelections << '     use '
+        path.push(klass.nodeName)
+        path.each do |t|
+          unless t == path.first
+            recommendedSelections << ':'
+            recommendedSelections << t
+            unless (t.object_id() == path.last.object_id())
+              recommendedSelections << ','
+            end
+          end
+        end
+        path.pop()
+        recommendedSelections << "\n"
+      end
+      getDefaultSelections(className, type, recommendedSelections, path)
+      path.pop()
+    end unless (associations.empty?())
+    recommendedSelections
+  end
+  
+  def deleteProductEntity(product, entity)
+    # remove the entry from product.oil
+    productOilFile = File.join(PRODUCTS_ROOT, product, 'DSL', 'product.oil')
+    cardinalityMatch = '((' + getCardinalities().join(')|(') + '))'
+    findAndReplaceInFile(productOilFile, /^\s*#{cardinalityMatch}\s*:\s*#{entity}\s*\n/, '')
+    # delete the specific oil file
+    fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'coverages', "#{entity}.oil")
+    unless (File.exists?(fileName)) then
+      fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'entities', "#{entity}.oil")
+    end
+    FileUtils.rm(fileName, :force => true)
+    # remove references from layout files
+    Dir.glob(File.join(PRODUCTS_ROOT, product, 'DSL', 'layouts', '*.oil'), File::FNM_PATHNAME) do |c|
+      # NOTE: entities and coverages can obviously have instructions bounded in {} after them
+      # e.g. title, hide etc.etc. so we need to make sure our search is fuzzy enough
+      # At this stage I have elected to just look for :Entity in any line and kill the line
+      findAndReplaceInFile(c, /^.*?:#{entity}.*?\n/, '')
+    end
+  end
+  
+  def updateEntityCardinality(product, entity, cardinality)
+    fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'product.oil')
+    findAndReplaceInFile(fileName, /(^\s+)[^\s]+(\s*:#{entity})/, "\\1#{cardinality}\\2")
+  end
+  
+  def saveEntityDetails(product, entity, selections)
+    # assert type as coverage and if the file doesn't exist assume entity
+    type = :coverage
+    fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'coverages', "#{entity}.oil")
+    unless (File.exists?(fileName)) then
+      type = :entity
+      fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'entities', "#{entity}.oil")
+    end
+    open(fileName, 'w') do |f|
+      f << "#{type} :" << entity << "\n"
+      selections.each do |s|
+        f << '    use ' << s << "\n"
+      end
+      f << "end#{type}"
+      f.close()
+    end
+  end
+
+  def getLibraryEntities(type)
+    if (type == :coverage) then
+      root = COVERAGE_DEF_ROOT
+    else
+      root = ENTITY_DEF_ROOT
+    end
+    entities = Array.new
+    Dir.glob(File.join(root, '*PropertyHash'), File::FNM_PATHNAME) do |c|
+      entities.push(File.basename(c.to_s).gsub(/(.*)PropertyHash/, '\1'))
+    end
+    entities.sort
+  end
+  
+  def getEntityDetails(product, entity)
+    # find the definition of this coverage in this product, could be entity or coverage
+    fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'coverages', "#{entity}.oil")
+    type = :coverage
+    unless (File.exists?(fileName)) then
+      fileName = File.join(PRODUCTS_ROOT, product, 'DSL', 'entities', "#{entity}.oil")
+      type = :entity
+    end
+    # get the library definition of the coverage
+    lcd = walkLibraryEntity(entity, type, nil)
+    # go through all the items in the oil file that have been used and "check" them
+    open(fileName) do |f|
+      CoverageInterpreter2.execute(f.read).each do |s|
+        lcd = lcd.gsub(/(\sname=\"#{s}\")/, '\1 checked="checked"')
+      end
+    end
+    # puts lcd
+    lcd
+  end
+  
+  def getCardinalities()
+    cardinalities = ['has_one', 'has_many']
+    cardinalities
+  end
+  
+  def updateDictionary(lang, key, value)
+    open(File.join(PRODUCTS_ROOT, "dictionary_#{lang}.rb"), 'r+') do |f|
+      content = f.read()
+      # is the string already in the dictionary?
+      if (content.match(/^\s+\"#{key}\"\s+=>\s+\"[^\"]*\"\s*,/) != nil) then
+        puts "Updating dictionary: Language[#{lang}] key [#{key}] value [#{value}]\n"
+        content.gsub!(/(^\s+\"#{key}\"\s+=>\s+\")[^\"]*(\"\s*,)/, "\\1#{value}\\2")
+      else
+        puts "Adding to dictionary: Language[#{lang}] key [#{key}] value [#{value}]\n"
+        newEntry = "\n      \"#{key}\" => \"#{value}\","
+        # add the new lookup at the start of the dictionary
+        content.gsub!(/(^\s*def\s+dictionary\s*\n\s*\{)/, "\\1#{newEntry}")
+      end
+      f.truncate(0)
+      f.rewind()
+      f.write(content)
+      f.close()
+
+    end
+  end
+  
+  def walkLibraryEntity(entity, type, path)
+    introduce_dictionary(PRODUCTS_ROOT, 'en')
+    if (path == nil) then
+      loadLibraryEntity(entity, type)
+      path = Array.new
+      path.push(entity)
+    else
+      path.push(entity.sub(/#{path.join()}/, ''))
+    end
+    result = ''
+    associations = eval(entity).reflect_on_all_associations()
+    #don't render markup if there's nothing there
+    unless(associations.empty?) then
+      result << '<ul>' << "\n"
+      associations.each do |a|
+        className = a.name.id2name
+        result << '<li>' << '<input type="checkbox" name="'
+        nodeName = eval(className).nodeName
+        path.push(nodeName)
+        path.each do |t|
+          unless t == path.first
+            result << ':' << t
+            unless (t.object_id() == path.last.object_id())
+              result << ','
+            end
+          end
+        end
+        path.pop()
+        result << '"/>' << '<a>' << nodeName << '</a>'
+        #  try and do a lookup on the dictionary
+        dictionaryKey = (entity + '_' + nodeName).downcase()
+        dictionaryTranslation = __(dictionaryKey)
+        if (dictionaryTranslation != dictionaryKey) then
+          result << '<p><small><i>' << dictionaryTranslation << '</i></small></p>'
+        end
+        result << walkLibraryEntity(className, type, path) << '</li>'
+        path.pop()
+      end
+      result << '</ul>'
+    end
+    result
+  end
+  
+  def copyDirectoryWithoutHiddenRecursively(src, dest)
+    # make the destination directory if it does not exist
+    unless (File.directory?(dest)) then
+      FileUtils.mkpath(dest)
+    end
+    # recursively copy files and folders without hidden files
+    Dir.glob(File.join(src, '*'), File::FNM_PATHNAME) do |p|
+      if (File.directory?(p))
+        copyDirectoryWithoutHiddenRecursively(p, File.join(dest, File.basename(p)))
+      else
+        FileUtils.cp(p, dest)
+      end
+    end
+  end
+  
+  def loadLibraryEntity(entity, type)
+    # now its time to dynamically load the the entity and its children from the library
+    if (type == :coverage) then
+      libraryPath = COVERAGE_DEF_ROOT
+    else
+      libraryPath = ENTITY_DEF_ROOT
+    end
+    require(File.join(libraryPath, entity + 'EntityModel.rb'))
+    require(File.join(libraryPath, entity + 'NodeName.rb'))
+  end
+  
+  def getPropertyHash(type, entity)
+    if (type == :coverage) then
+      libraryPath = COVERAGE_DEF_ROOT
+    else
+      libraryPath = ENTITY_DEF_ROOT
+    end
+    return YAML::load(open(File.join(libraryPath, entity + 'PropertyHash'), 'r'))
+  end
+  
+  def findAndReplaceInFile(fileName, findExpression, replaceExpression)
+    open(fileName, 'r+') do |f|
+      content = f.read()
+      content.gsub!(findExpression, replaceExpression)
+      f.truncate(0)
+      f.rewind()
+      f.write(content)
+      f.close()
+    end
+  end
+end