xamplr-gen 1.9.0

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

@@ -0,0 +1,277 @@
+
+  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::XamplWithSimpleContent
+
+    @@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.name}", "#{attribute.namespace}" ],
+|
+|  else
+|
+                     [ :@#{attribute.name}, "#{attribute.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
+|
+|@element.child_element_child.each{ | child_element |
+|  element_attribute_name = @lookup_element[child_element.name].attribute_name
+|
+      init_#{child_element.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

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

@@ -0,0 +1,38 @@
+|
+| unless 'XamplAdHoc' == package_name
+|
+module #{package_name}
+|
+| end
+|
+
+  require "xamplr"
+  include Xampl
+
+|
+| @required_packages.each_key{ | required_package_name |
+|
+  require "#{required_package_name}"
+|
+| }
+|
+
+|
+| if @options then
+|   @options.resolve_child.each{ | r |
+|     if r.namespace and (0 < r.namespace.length) and r.preferred_prefix and (0 < r.preferred_prefix.length) then
+|
+  XamplObject.ns_preferred_prefix("#{r.namespace}", "#{r.preferred_prefix}")
+|
+|     end
+|   }
+| end
+|
+#{place}
+|
+| unless 'XamplAdHoc' == package_name
+|
+end
+|
+| end
+|

data/lib/xamplr-gen/xampl-cl-gen.rb

@@ -0,0 +1,89 @@
+
+#require 'xampl-generator'
+
+include XamplGenerator
+include Xampl
+
+class ProjectGenerator
+
+  def directory
+    File.join(%w{ . xampl_generated_code })
+  end
+
+  def filenames
+    Dir.glob("./xml/**/*.xml")
+  end
+
+  def print_base_filename
+    File.join(%w{ . generated })
+  end
+
+  def print_options
+    # return an array containing any (or none) of:
+    #    :schema    -- a schema-like xml representation of the generated code
+    #    :graphml   -- a graphml file describing the class model (compatible with yEd)
+    #    :yuml      -- a yuml file that represents a simplified class model (compatible with yUML)
+
+    # [:schema, :graphml, :yuml]
+    []
+  end
+
+  def print
+    nil
+  end
+
+  def persisted_attributes
+    %w{ pid }
+  end
+
+  def indexed_attributes
+    %w{ id }
+  end
+
+  def resolve_namespaces
+    # any array of arrays
+    # each sub-array:
+    #    0: a string or an array of strings, containing xml namespaces found in the example xml files
+    #       an empty string is the default namespace
+    #    1: a ruby Module name (get the cases right)
+    #    2: a namespace prefix used when writing xml, optional. A generated prefix will be used otherwise.
+    []
+  end
+
+  def generate
+
+#      Xampl.set_default_persister_kind(:simple)
+    Xampl.set_default_persister_kind(:in_memory)
+#      Xampl.set_default_persister_kind(:filesystem)
+#      Xampl.set_default_persister_kind(:tokyo_cabinet)
+#      Xampl.set_default_persister_format(:xml_format)
+
+    Xampl.transaction("project-generation") do
+
+      options = Options.new do | opts |
+        persisted_attributes.each do | pattr |
+          opts.new_index_attribute(pattr).persisted = true
+        end
+
+        indexed_attributes.each do | iattr |
+          opts.new_index_attribute(iattr)
+        end
+
+        resolve_namespaces.each do | namespace, ruby_module_name, output_ns_prefix |
+          opts.resolve(namespace, ruby_module_name, output_ns_prefix)
+        end
+
+      end
+
+      generator = Generator.new('generator')
+      generator.go(:options => options,
+                   :filenames => filenames,
+                   :directory => directory)
+
+      puts generator.print_elements(print_base_filename, print_options)
+
+      Xampl.rollback
+    end
+  end
+end
+

data/lib/xamplr-gen/xampl-generator.rb

@@ -0,0 +1,561 @@
+
+module XamplGenerator
+
+  class Attribute
+    attr_accessor :tag_name
+  end
+
+  class StandardGeneratorTemplates
+    include TemplateEngine
+
+    attr_accessor :element, :package_name, :place, :lookup_element, :options, :required_packages
+
+    def initialize
+      super
+      @element = nil
+      @package_name = nil
+      @place = nil
+      @lookup_element = {}
+      @options = nil
+      @required_packages = {}
+    end
+  end
+
+  class Generator
+
+    attr_accessor :elements_map, :options, :templates
+
+    @@standard_templates = [
+            "xamplr-gen/templates/child_modules.template",
+            "xamplr-gen/templates/child.template",
+            "xamplr-gen/templates/child_indexed.template",
+            "xamplr-gen/templates/element_classes.template",
+            "xamplr-gen/templates/element_data.template",
+            "xamplr-gen/templates/element_empty.template",
+            "xamplr-gen/templates/element_mixed.template",
+            "xamplr-gen/templates/element_simple.template",
+            "xamplr-gen/templates/package.template",
+    ]
+
+    def initialize(options_in = nil, *predefined_elements)
+      @elements_map = {}
+      @xpp = nil
+      @templates = nil
+      @generated_package_map = nil
+
+      if options_in then
+        @options = options_in
+      else
+        @options = Xampl.make(Options) do |options|
+          options.new_index_attribute("id")
+          options.new_index_attribute("pid").persisted = true;
+
+          options.new_resolve do |resolver|
+            resolver.pkg = "XamplAdHoc"
+            resolver.namespace=""
+          end
+        end
+      end
+
+      predefined_elements.each do |elements|
+        throw :elements_need_a_pid unless elements.pid
+        @elements_map[elements.pid] = elements
+      end
+    end
+
+    def start_element(parent)
+      name = @xpp.name
+      namespace = @xpp.namespace
+      namespace = "" unless namespace
+      is_empty = @xpp.emptyElement
+
+      nstag = "{{#{namespace}}}#{name}"
+
+      elements = @elements_map[namespace]
+      if nil == elements then
+        elements = Elements.new
+        @elements_map[namespace] = elements
+      end
+
+      element = elements.element_child[name]
+      if nil == element then
+        element = elements.new_element(name)
+      end
+
+      element.namespace = namespace
+      element.nstag = nstag
+      element.empty = is_empty
+
+      @xpp.attributeName.each_index do |i|
+        attribute = Attribute.new
+        attribute.name = @xpp.attributeName[i]
+        attribute.namespace = @xpp.attributeNamespace[i]
+        element.add_attribute(attribute)
+      end
+
+      if parent then
+        parent.new_child_element(nstag) do |ce|
+          ce.element_name = name
+          ce.namespace = namespace
+        end
+      end
+      return element
+    end
+
+    def parse_filename(filename)
+      @xpp = Xampl_PP.new
+      @xpp.input = File.new(filename)
+      parse
+    end
+
+    def parse_string(string)
+      @xpp = Xampl_PP.new
+      @xpp.input = string
+      parse
+    end
+
+    def parse
+      element_stack = []
+      current_element = nil
+
+      while not @xpp.endDocument? do
+        case @xpp.nextEvent
+          when Xampl_PP::START_ELEMENT
+            element_stack.push current_element unless nil == current_element
+            current_element = start_element(current_element)
+          when Xampl_PP::END_ELEMENT
+            current_element = element_stack.pop
+          when Xampl_PP::TEXT,
+                  Xampl_PP::CDATA_SECTION,
+                  Xampl_PP::ENTITY_REF
+            if current_element then
+              text = @xpp.text
+              if (nil != @xpp.text) then
+                text = text.strip
+                current_element.found_text_content if 0 < text.size
+              end
+            end
+        end
+      end
+    end
+
+    def comprehend_from_files(filenames)
+      filenames.each do |filename|
+        puts "comprehend file #{filename}"
+        parse_filename(filename)
+      end
+    end
+
+    def comprehend_from_strings(strings)
+      strings.each do |string|
+        parse_string(string)
+      end
+    end
+
+    def analyse
+      namespace_package_map = {}
+      namespace_prefix_map = {}
+      options.resolve_child.each do |resolve|
+        namespace_package_map[resolve.namespace] = resolve.pkg
+      end
+
+      @elements_map.each do |ns, elements|
+        package = namespace_package_map[ns]
+
+        elements.element_child.each do |element|
+          element.package = package
+          element.analyse(options)
+        end
+      end
+
+      @required_packages = {}
+      @elements_map.each do |ns, elements|
+        package = namespace_package_map[ns]
+
+        required = @required_packages[package]
+        unless required then
+          required = {}
+          @required_packages[package] = required
+        end
+
+        elements.element_child.each do |element|
+          element.child_element_child.each do |child_element|
+            celement = child_element.find_element(@elements_map)
+            #required[celement.package] = celement.package
+            unless package == celement.package then
+              required[celement.package] = celement.package
+            end
+          end
+        end
+      end
+    end
+
+    def ensure_templates
+      return if @templates
+
+      @templates = StandardGeneratorTemplates.new
+      @templates.compile_scripts(@@standard_templates)
+    end
+
+    def find_place(directory_name, package)
+      #puts "find_place:: package: #{package}"
+
+      @generated_package_map = {} unless @generated_package_map
+
+      place = @generated_package_map[package]
+      if nil == place then
+        place = ""
+        @generated_package_map[package] = place
+      end
+      return place
+    end
+
+    def generate(directory_name, params={:verbose => false}, &eval_context)
+      if directory_name then
+        FileUtils.mkdir_p(directory_name) unless File.exist?(directory_name)
+      end
+
+      ensure_templates
+
+      module_names = Set.new
+      @elements_map.each do |ns, elements|
+        elements.element_child.each do |element|
+          module_names << element.package
+          break
+        end
+      end
+
+      lookup_element = {}
+      @elements_map.each do |ns, elements|
+        elements.element_child.each do |element|
+          lookup_element[element.nstag] = element
+        end
+      end
+
+      @templates.lookup_element = lookup_element
+
+      @elements_map.each do |ns, elements|
+        elements.element_child.each do |element|
+          place = find_place(directory_name, element.package)
+
+          @templates.element = element
+          @templates.package_name = element.package
+
+          if element.class_name == element.package then
+            puts "ERROR: Class #{ element.package } is in a module with the same name -- this NOT going to work"
+          elsif module_names.member?(element.class_name)
+            puts "WARNING: a Class and a Module have the same name (#{ element.package }) -- this is highly unlikely to work"
+          end
+
+          @templates.child_modules(place)
+        end
+      end
+
+      @elements_map.each do |ns, elements|
+        elements.element_child.each do |element|
+          place = find_place(directory_name, element.package)
+
+          @templates.element = element
+          @templates.package_name = element.package
+
+          @templates.element_classes(place)
+        end
+      end
+
+      @generated_package_map.each do |package_name, definition|
+        package_name = "XamplAdHoc" unless package_name
+
+        @templates.element = nil
+        @templates.package_name = package_name
+        @templates.options = @options
+
+        @templates.required_packages = @required_packages[package_name] || {}
+
+        @templates.place = definition
+
+        package_definition = @templates.package
+
+        if directory_name then
+          output_filename = File.join(directory_name, "#{package_name}.rb")
+          puts "WRITE TO FILE: #{output_filename}"
+          #puts package_definition
+          File.open(output_filename, "w") do |file|
+            file.puts package_definition
+          end
+        end
+        if block_given? then
+          package_name = "XamplAdHoc" unless package_name
+          puts "EVALUATE: #{package_name}"
+          eval_context.call(package_definition, package_name)
+        end
+      end
+
+      report_elements if params[:verbose]
+    end
+
+    def report_elements
+      @elements_map.each_value do |elements|
+        puts elements.pp_xml
+      end
+    end
+
+    def print_elements(base_filename, print_options=nil)
+      return unless base_filename
+      return unless print_options
+      return if 0 == print_options.size
+
+      root = Elements.new
+      @elements_map.each_value do |elements|
+        elements.element_child.each do |element|
+          root.children << element
+        end
+      end
+
+      print_options.each do | print_option |
+        case print_option
+          when :schema then
+            File.open("#{base_filename}.xml", "w") do |out|
+              root.pp_xml(out)
+            end
+          when :graphml then
+            graphml_out = GraphMLOut.new(@elements_map)
+            graphml_out.write_graph_ml(base_filename)
+          when :yuml then
+            yuml_out = YUMLOut.new(@elements_map)
+            yuml_out.write_yuml(base_filename)
+        end
+      end
+    end
+
+    def go(args, &eval_context)
+      options = args[:options]
+      if options then
+        @options = options
+      end
+
+      strings = args[:strings]
+      if strings then
+        comprehend_from_strings(strings)
+      end
+
+      filenames = args[:filenames]
+      if filenames then
+        comprehend_from_files(filenames)
+      end
+
+      directory = args[:directory]
+      if directory then
+        generate_to_directory(directory, args)
+      else
+        generate_and_eval(args) do |module_definition, name|
+          yield(module_definition, name)
+        end
+      end
+    end
+
+    def generate_to_directory(directory_name, params={:verbose => false})
+      analyse
+      return generate(directory_name, params)
+    end
+
+    def generate_and_eval(params={:verbose => false}, &eval_context)
+      analyse
+      return generate(nil, params, &eval_context)
+    end
+
+    def Generator.choose_names(original_name, attr_prefix="_", attr_suffix="_")
+
+#      name = original_name.gsub(/[^a-zA-Z_]+/, "_")
+
+      # NOTE (2009-04-16) -- if tag starts with a number, prefix it with an 'x'
+      name = original_name.sub(/^([0-9])/) { | m | "x" + m }
+      name = name.gsub(/[^a-zA-Z0-9_]+/, "_")
+
+
+      attr_name = name.gsub(/[A-Z]+/, "_\\&")
+      attr_name.gsub!(/__+/, "_")
+      attr_name = attr_name[1..-1] if "_"[0] == attr_name[0]
+      attr_name.downcase!
+
+      name.gsub!(/[A-Z]/, "_\\&")
+      name.gsub!(/__+/, "_")
+      class_name = ""
+      #name.each("_") do |chunk|
+      name.split("_").each do |chunk|
+        class_name << chunk.capitalize
+      end
+      class_name.gsub!("_", "")
+
+      return class_name, attr_name
+    end
+
+    def print_stats
+      count = 0
+      @elements_map.each do |ns, elements|
+        count += elements.element_child.size
+        printf("namespace: %s, element: %d\n", ns, elements.element_child.size)
+      end
+      printf("counts of:: namespace: %d, element: %d\n", @elements_map.size, count)
+      @elements_map.each do |ns, elements|
+        puts elements.pp_xml
+      end
+    end
+  end
+
+  class Options
+    def resolve(namespace, pkg="XamplAdHoc", preferred_prefix=nil)
+      if (namespace.kind_of?(Array)) then
+        namespace.each do |ns, prefix|
+          self.new_resolve do |resolver|
+            resolver.pkg = pkg
+            resolver.namespace = ns
+            resolver.preferred_prefix = prefix
+          end
+        end
+      else
+        self.new_resolve do |resolver|
+          resolver.pkg = pkg
+          resolver.namespace = namespace
+          resolver.preferred_prefix = preferred_prefix
+        end
+      end
+    end
+  end
+
+  class ChildElement
+    def find_element(map)
+      elements = map[self.namespace]
+      return elements.element[self.element_name]
+    end
+  end
+
+  class Element
+    def found_text_content
+      self.has_content = true
+    end
+
+    def analyse(options)
+      is_empty, is_simple, is_data, is_mixed = false
+
+      class_name, attribute_name = Generator.choose_names(@name)
+      @class_name = class_name unless @class_name
+      @attribute_name = attribute_name unless @attribute_name
+
+      no_children = (0 == @child_element_child.size)
+
+      unless @kind then
+        if no_children then
+          is_simple = @has_content
+          is_empty = !is_simple
+        else
+          is_mixed = @has_content
+          is_data = !@has_content
+        end
+
+        # this isn't a very strong piece of information, can't do much about it.
+        #attribute_like = ((0 == @attribute_child.size) and is_simple)
+
+        if    is_empty  then
+          @kind = "empty"
+        elsif is_simple then
+          @kind = "simple"
+        elsif is_data   then
+          @kind = "data"
+        elsif is_mixed  then
+          @kind = "mixed"
+        else
+          throw "no kind determined" # this should be impossible
+        end
+      end
+
+      unless self.indexed_by_attr then
+        attribute_child.each do |attribute|
+          aname_orig = attribute.name
+          class_name, aname = Generator.choose_names(aname_orig)
+          attribute.name = aname
+          attribute.tag_name = aname_orig
+
+          options.index_attribute_child.each do |iattr|
+            if aname == iattr.name then
+              self.indexed_by_attr = aname
+              self.persisted = iattr.persisted
+              break
+            end
+          end
+        end
+
+        if self.persisted then
+          attribute = Attribute.new
+          attribute.name = 'scheduled_for_deletion_at'
+          attribute.tag_name = 'scheduled-for-deletion-at'
+          attribute.namespace = nil
+          self.add_attribute(attribute)
+        end
+
+      end
+    end
+  end
+
+  def XamplGenerator.from_command_line(options=nil)
+    opts = GetoptLong.new(
+            ["--options", "-o", GetoptLong::REQUIRED_ARGUMENT],
+            ["--elements", "-e", GetoptLong::REQUIRED_ARGUMENT],
+            ["--gen:options", "-O", GetoptLong::OPTIONAL_ARGUMENT],
+            ["--gen:elements", "-E", GetoptLong::OPTIONAL_ARGUMENT],
+            ["--directory", "-d", GetoptLong::REQUIRED_ARGUMENT],
+            ["--help", "-h", GetoptLong::NO_ARGUMENT],
+            ["--version", "-v", GetoptLong::NO_ARGUMENT]
+    )
+
+    write_options = nil
+    write_elements = nil
+    directory = File.join(".", "tmp")
+
+    opts.each do |opt, arg|
+      case opt
+        when "--help" then
+          puts "--help, -h          :: this help message"
+          puts "--options, -o       :: xml file seting the generation options"
+          puts "--elements, -e      :: xml file providing a hint 'schema' (very optional)"
+          puts "--gen:options, -O   :: write an xml file describing the options used (default gen-options.xml)"
+          puts "--gen:elements, -E  :: write an xml file describing the 'schema' (default gen-elements.xml)"
+          puts "--directory, -o     :: where to write the generated files (default #{directory})"
+          puts "--version, -o       :: what version of xampl is this?"
+          exit
+        when "--version" then
+          puts "version 0.0.0"
+          exit
+        when "--directory"
+          directory = arg
+        when "--options"
+          puts "sorry, cannot read options yet"
+        when "--elements"
+          puts "sorry, cannot read elements yet"
+        when "--gen:options"
+          write_options = (arg and (0 < arg.length)) ? arg : "gen-options.xml"
+        when "--gen:elements"
+          write_elements = (arg and (0 < arg.length)) ? arg : "gen-elements.xml"
+        else
+          puts "  #{opt} #{arg}"
+      end
+    end
+
+    puts "write options to: #{write_options}" if write_options
+    puts "write elements to: #{write_elements}" if write_elements
+    puts "write generated code to: #{directory}" if directory
+
+    generator = Generator.new(options)
+
+    filenames = []
+    ARGV.each do |name|
+      filenames << name
+    end
+
+    if 0 < filenames.length then
+      generator.comprehend_from_files(filenames)
+      generator.generate_to_directory(directory)
+
+      generator.print_elements(write_elements) if write_elements
+    end
+  end
+end