xamplr-gen 1.9.0

data/lib/xamplr-gen/simpleTemplate/play_noblanks.r6

@@ -0,0 +1,21 @@
+[1]
+| 
+| some_number = 42
+|# def gen_some_number
+|#   42 + rand
+|# end
+|
+[2]
+[3]Hello there(play_noblanks)! #{@message}
+[4]
+|
+| another_number = 99
+| result << sprintf("execute gen: %d\n", gen_some_number)
+|
+[5]
+[6]    some number: [[[#{some_number}]]]
+[7]gen some number: [[[#{gen_some_number}]]]
+[8] another number: [[[#{another_number}]]]
+[9]
+[10]play_noblanks _____________________________________________________
+[11]

data/lib/xamplr-gen/simpleTemplate/playq.r6

@@ -0,0 +1,16 @@
+| 
+| some_number = 42
+| def gen_some_number
+|   42 + rand
+| end
+|
+
+ Hello there (play)! #{@message}
+
+ one: 'one #{gen_some_number}'
+ two: "two #{gen_some_number}"
+
+    some number: [[[#{some_number}]]]
+gen some number: [[[#{gen_some_number}]]]
+play __________________________________________________________
+

data/lib/xamplr-gen/simpleTemplate/r6.rb

@@ -0,0 +1,87 @@
+#! /usr/bin/env ruby
+
+require "xamplr/simpleTemplate/simple-template"
+
+###
+###  and this is how it can be used...
+###
+
+# Define a class to hold the template methods. Any attributes defined by this
+# class will be available to be used by the templates when they are 'run'.
+# These are expected to be set up by the template-invoking program. This
+# class defines a single attribute 'message' 
+
+class R6_Template
+  include TemplateEngine
+  attr_accessor :message
+end
+
+# Now we need to get some templates into place. We are providing a list of
+# files here, but it is possible to imagine using ARGS to get filenames from
+# the command line. Simply pass the list to the compile_script method.
+
+files = [ "play.r6", "play_more.r6", "playq.r6", "play_noblanks.r6"];
+
+engine = R6_Template.new
+engine.compile_scripts(files)
+
+# For illustrative purposes, go over the file arguments and execute
+# the corresponding method defined above. The file names are used by the
+# Template Engine to create a method that, when called, will 'execute' the
+# template. The method name will be chosen by removing the filename extension.
+
+files.each { | script_name |
+  method_name = File::basename(script_name, ".*")
+
+  # just a silly message that identifies the script that is running
+  engine.message = sprintf("this is script '%s'", method_name)
+
+  puts "#{method_name}*******************"
+  what = engine.send(method_name);
+  puts "{{{#{what}}}}*******************"
+}
+
+# This time call the play method directly. There must be a template
+# called 'play' for this to work.
+
+engine.message = "this is script 'play' -- called explicitly"
+puts "!!play!!*******************"
+what = engine.play()
+puts "{{{#{what}}}}*******************"
+
+# Now do the same thing as the illustrative loop above but writing to a file
+# with the script name and a ".out" extension.
+
+files.each { | script_name |
+  method_name = File::basename(script_name, ".*")
+  engine.message = sprintf("this is script '%s'", method_name)
+  File.open(sprintf("%s.out", method_name), "w") { | file |
+    engine.send(method_name, file);
+  }
+}
+
+# Write to a file called "play-x.out", again, there must be a play template
+# defined.
+
+engine.message = "this is script 'play' -- called explicitly"
+File.open("play-x.out", "w") { | file |
+  engine.play(file)
+}
+
+# Build up a single string by applying all the templates
+long_string = ""
+files.each { | script_name |
+  method_name = File::basename(script_name, ".*")
+  engine.message = sprintf("this is script '%s'", method_name)
+  what = engine.send(method_name, long_string);
+}
+puts "!!{{{#{long_string}}}}!!*******************"
+
+# This will fail, because the template methods are only defined on the
+# instance of the engine that compiled them.
+#
+#engine2 = R6_Template.new
+#engine2.message = "this is script 'play' -- called explicitly"
+#File.open("play-x.out", "w") { | file |
+#  engine2.play(file)
+#}

data/lib/xamplr-gen/simpleTemplate/simple-template.rb

@@ -0,0 +1,75 @@
+module TemplateEngine
+  attr_accessor :method_to_file_name, :file_name_to_method
+
+  def initialize
+    @method_to_file_name = Hash.new()
+    @file_name_to_method = Hash.new()
+  end
+
+  #  def macro(name, &block)
+  #    Kernel.send(:define_method, name) { |*args|
+  #      puts block.call(args)
+  #    }
+  #  end
+
+  def build_script(template_file_name, method_name)
+
+    # Build the definition of a method (called 'method_name') that
+    # will execute the template (in the file 'template_file_name'). There will
+    # be an optional argument that defaults to the empty string (and so this
+    # method will, by default, build a new string representing the result). If
+    # the argument is supplied, it must respond to the "<<" (append) method.
+    #
+    # The result variable is available in the template. To write to the result
+    # from Ruby code, result << sprintf("hello %s", "world") in the template
+    # will get its output where expected.
+
+    found_template_file_name = nil
+    $LOAD_PATH.each{ | directory |
+      possible_template_file_name = File.join(directory, template_file_name)
+      if File.exists?(possible_template_file_name)
+        found_template_file_name = possible_template_file_name
+      end
+    }
+    return unless found_template_file_name
+    File.open(found_template_file_name) do | file |
+      tmp = ""
+      r = "
+  def #{method_name}(result=\"\")
+    result << \"\"
+      "
+      while line = file.gets
+        if line[0] == ?|
+          if (0 < tmp.length)
+            r << "    result << \"#{tmp.gsub("\"", "\\\"")}\""
+            tmp = ""
+          end
+          r << "   #{line[1..-1]}"
+        else
+          #tmp << line.chomp << "\n"
+          tmp << line
+        end
+      end
+      r << "    result << \"#{tmp.gsub("\"", "\\\"")}\""
+      r << "
+    result
+  end
+"
+    end
+  end
+
+  def compile_scripts(files)
+    files.each { | script_name |
+      method_name = File::basename(script_name, ".*")
+      #puts "COMPILE: [[#{method_name}]]"
+
+      @method_to_file_name[method_name] = script_name;
+      @file_name_to_method[script_name] = method_name;
+
+      the_script = build_script(script_name, method_name)
+      #puts the_script
+      instance_eval(the_script, "SCRIPT:#{script_name}", 1)
+    }
+  end
+end
+

data/lib/xamplr-gen/templates/.cvsignore

@@ -0,0 +1,3 @@
+nice-try
+old
+.cvs.log

data/lib/xamplr-gen/templates/child.template

@@ -0,0 +1,47 @@
+
+  module #{element.class_name}AsChild
+    def #{element.attribute_name}_child
+      accessed
+      @#{element.attribute_name}_child
+    end
+
+    def #{element.attribute_name}_child=(v)
+      accessed
+      @#{element.attribute_name}_child = v
+    end
+
+    alias #{element.attribute_name} #{element.attribute_name}_child
+    alias #{element.attribute_name}= #{element.attribute_name}_child=
+  
+    def init_#{element.attribute_name}_as_child
+      @#{element.attribute_name}_child = []
+    end
+
+    def add_#{element.attribute_name}(#{element.attribute_name})
+      accessed
+      @children << #{element.attribute_name}
+      @#{element.attribute_name}_child << #{element.attribute_name}
+      #{element.attribute_name}.add_parent(self)
+      changed
+      return #{element.attribute_name}
+    end
+  
+    def new_#{element.attribute_name}
+      accessed
+      #{element.attribute_name} = #{element.class_name}.new
+      yield(#{element.attribute_name}) if block_given?
+      return add_#{element.attribute_name}(#{element.attribute_name})
+    end
+
+    def ensure_#{element.attribute_name}
+      accessed
+      new_#{element.attribute_name} if 0 == #{element.attribute_name}.size
+    end
+
+    def remove_#{element.attribute_name}(#{element.attribute_name})
+      accessed
+      changed
+      @#{element.attribute_name}_child.delete(#{element.attribute_name})
+      @children.delete(#{element.attribute_name})
+    end
+  end

data/lib/xamplr-gen/templates/child_indexed.template

@@ -0,0 +1,89 @@
+
+  module #{element.class_name}AsChild
+    require "xamplr/indexed-array"
+  
+    def #{element.attribute_name}_child
+      accessed
+      @#{element.attribute_name}_child
+    end
+
+    def #{element.attribute_name}_child=(v)
+      accessed
+      @#{element.attribute_name}_child = v
+    end
+
+    alias #{element.attribute_name} #{element.attribute_name}_child
+    alias #{element.attribute_name}= #{element.attribute_name}_child=
+  
+    def init_#{element.attribute_name}_as_child
+      @#{element.attribute_name}_child = IndexedArray.new
+    end
+  
+    def add_#{element.attribute_name}(#{element.attribute_name})
+      accessed
+      index = #{element.attribute_name}.get_the_index
+      if(nil == index) then
+        raise Xampl::XamplException.new("no value for the index '#{element.indexed_by_attr}' of #{element.attribute_name} defined in : " << #{element.attribute_name}.pp_xml)
+      end
+
+      existing = @#{element.attribute_name}_child[index]
+
+      return existing if existing == #{element.attribute_name}
+
+      self.remove_#{element.attribute_name}(index) if existing
+
+      @children << #{element.attribute_name}
+      @#{element.attribute_name}_child[index] = #{element.attribute_name}
+
+      #{element.attribute_name}.add_parent(self)
+
+      changed
+      return #{element.attribute_name}
+    end
+  
+    def new_#{element.attribute_name}(index)
+      accessed
+
+      #{element.attribute_name} = nil
+|
+|if @element.persisted then
+|
+      #{element.attribute_name} = #{element.class_name}.lookup(index) if Xampl.persister and Xampl.persister.automatic
+|
+|end
+|
+      #{element.attribute_name} = #{element.class_name}.new(index) unless #{element.attribute_name}
+
+      yield(#{element.attribute_name}) if block_given?
+      return add_#{element.attribute_name}(#{element.attribute_name})
+    end
+
+    def ensure_#{element.attribute_name}(index)
+      accessed
+
+      #{element.attribute_name} = @#{element.attribute_name}_child[index]
+      return #{element.attribute_name} if #{element.attribute_name} 
+
+|
+|if @element.persisted then
+|
+      #{element.attribute_name} = #{element.class_name}.lookup(index) if Xampl.persister and Xampl.persister.automatic
+|
+|end
+|
+      #{element.attribute_name} = #{element.class_name}.new(index) unless #{element.attribute_name}
+
+      yield(#{element.attribute_name}) if block_given?
+      return add_#{element.attribute_name}(#{element.attribute_name})
+    end
+
+    def remove_#{element.attribute_name}(index)
+      accessed
+      changed
+      unless String === index or Symbol === index then
+        index = index.get_the_index
+      end
+      #{element.attribute_name} = @#{element.attribute_name}_child.delete(index) if index
+      @children.delete(#{element.attribute_name})
+    end
+  end

data/lib/xamplr-gen/templates/child_modules.template

@@ -0,0 +1,5 @@
+| if @element.indexed_by_attr then
+|   child_indexed(result)
+| else
+|   child(result)
+| end

data/lib/xamplr-gen/templates/element_classes.template

@@ -0,0 +1,11 @@
+| if "empty" == @element.kind then
+|   element_empty(result)
+| elsif "simple" == @element.kind then
+|   element_simple(result)
+| elsif "data" == @element.kind then
+|   element_data(result)
+| elsif "mixed" == @element.kind then
+|   element_mixed(result)
+| else
+|   raise Xampl::XamplException.new(:unkown_kind_of_element, "unknown element kind: '#{@element.kind}'")
+| end

data/lib/xamplr-gen/templates/element_data.template

@@ -0,0 +1,283 @@
+
+|
+  class #{@element.class_name}
+|
+|if @element.persisted then
+|
+    include Xampl::XamplPersistedObject
+
+    #supports class based over-ride of persister format
+    @@default_persister_format = nil
+
+    def default_persister_format
+      @@default_persister_format
+    end
+    def #{@element.class_name}.default_persister_format
+      @@default_persister_format
+    end
+    def #{@element.class_name}.set_default_persister_format(format)
+      @@default_persister_format = format
+    end
+
+    def #{@element.class_name}.find_by_query
+      things = Xampl.find_xampl do | q |
+         q.add_condition('class', :equals, self.name)
+         yield(q)
+       end
+    end
+
+
+|
+|else
+|
+    include Xampl::XamplObject
+|
+|end
+|
+    include Xampl::XamplWithDataContent
+
+    @@tag = "#{@element.name}"
+    @@ns = "#{@element.namespace}"
+    @@ns_tag = "{#{@element.namespace}}#{@element.name}"
+    @@module_name = "#{@package_name}"
+    @@safe_name = "#{@package_name}_#{@element.attribute_name}"
+    @@attributes = [
+|
+|@element.attribute_child.each{ | attribute |
+|  if attribute.namespace then
+|
+                     [ :@#{attribute.name}, "#{attribute.tag_name}", "#{attribute.namespace}" ],
+|
+|  else
+|
+                     [ :@#{attribute.name}, "#{attribute.tag_name}" ],
+|
+|  end
+|}
+|
+                   ]
+|
+|@element.child_element_child.each{ | child_element |
+|  element_class_name = @lookup_element[child_element.name].class_name
+|  element_package = @lookup_element[child_element.name].package
+|
+    include #{element_package}::#{element_class_name}AsChild
+|
+|}
+|
+|
+
+|
+|if @element.persisted then
+|
+
+    def #{@element.class_name}.lookup(pid)
+      Xampl.lookup(#{@element.class_name}, pid)
+    end
+
+    def #{@element.class_name}.[](pid)
+      Xampl.lookup(#{@element.class_name}, pid)
+    end
+|
+|end
+|
+|@element.attribute_child.each{ | attribute |
+|  if attribute.name == @element.indexed_by_attr and @element.persisted then
+|
+
+    def #{attribute.name}
+      @#{attribute.name}
+    end
+
+    def #{attribute.name}=(v)
+      accessed
+      # This is kind of optimistic, I think you are in trouble if you do this
+      Xampl.auto_uncache(self) if @#{attribute.name}
+      @#{attribute.name} = v
+      changed
+      Xampl.auto_cache(self) if v
+    end
+|
+|  else
+|
+
+    def #{attribute.name}
+      accessed
+      @#{attribute.name}
+    end
+
+    def #{attribute.name}=(v)
+     accessed
+     changed
+     @#{attribute.name} = v
+    end
+|
+|  end
+|}
+|
+|  if @element.indexed_by_attr then
+|
+
+    def initialize(index=nil)
+      @#{@element.indexed_by_attr} = index if index
+      super()
+|
+| else
+|
+
+    def initialize
+      super
+|
+|end
+|
+|if 0 < @element.attribute_child.size then
+|
+
+|
+|end
+|
+|@element.attribute_child.each{ | attribute |
+|
+      @#{attribute.name} = nil if not defined? @#{attribute.name}
+|
+|}
+|
+
+      init_xampl_object
+      init_data_content
+|
+|@element.child_element_child.each{ | child_element |
+|  element_attribute_name = @lookup_element[child_element.name].attribute_name
+|
+      init_#{element_attribute_name}_as_child
+|
+|}
+|
+
+      yield(self) if block_given?
+      init_hook
+
+      changed
+    end
+
+    def clear_non_persistent_index_attributes
+|
+|@element.attribute_child.each{ | attribute |
+|  unless attribute.name == @element.indexed_by_attr and @element.persisted then
+|
+      @#{attribute.name} = nil
+|
+|  end
+|}
+|
+    end
+
+    def append_to(other)
+      other.add_#{@element.attribute_name}(self)
+    end
+
+|
+|if @element.persisted then
+|
+    def #{@element.class_name}.persisted?
+      return :#{@element.indexed_by_attr}
+    end
+
+    def persisted?
+      return :#{@element.indexed_by_attr}
+    end
+
+|
+|else
+|
+    def #{@element.class_name}.persisted?
+      return nil
+    end
+
+    def persisted?
+      return nil
+    end
+
+|
+|end
+|
+    def #{@element.class_name}.tag
+      @@tag
+    end
+
+    def #{@element.class_name}.ns
+      @@ns
+    end
+
+    def #{@element.class_name}.ns_tag
+      @@ns_tag
+    end
+
+    def #{@element.class_name}.safe_name
+      @@safe_name
+    end
+
+    def #{@element.class_name}.module_name
+      @@module_name
+    end
+
+    def tag
+      @@tag
+    end
+
+    def ns
+      @@ns
+    end
+
+    def ns_tag
+      @@ns_tag
+    end
+
+    def safe_name
+      @@safe_name
+    end
+
+    def module_name
+      @@module_name
+    end
+
+    def attributes
+      @@attributes
+    end
+|
+|if @element.indexed_by_attr
+|
+
+    def indexed_by
+      :#{@element.indexed_by_attr}
+    end
+
+    def get_the_index
+      @#{@element.indexed_by_attr}
+    end
+
+    def set_the_index(index)
+      @#{@element.indexed_by_attr} = index
+    end
+|
+|end
+|
+
+    def substitute_in_visit(visitor)
+      return visitor.substitute_in_visit_#{@element.attribute_name}(self) || self
+    end
+
+    def before_visit(visitor)
+      visitor.before_visit_#{@element.attribute_name}(self)
+    end
+
+    def visit(visitor)
+      visitor.visit_#{@element.attribute_name}(self)
+    end
+
+    def after_visit(visitor)
+      visitor.after_visit_#{@element.attribute_name}(self)
+    end
+
+    Xampl::FromXML::register(#{@element.class_name}::tag, #{@element.class_name}::ns_tag, #{@element.class_name})
+  end