4

Following is the iterative tree, done in html.erb, which reaches only two levels in a tree structure:

      <ul>
    <li><%= root_template.id  %></li>
      <ul>
          <% for template in root_template.children  %>
              <li><%= template.id  %></li>
              <% if template.has_children? %>
                <ul>
                <% for template_child in template.children  %>
                    <li><%= template_child.id  %></li>
                <% end %>
                </ul>
              <% end %>
          <% end %>
      </ul>
  </ul>

Result: iterative

I wanted to move the code in the helper files and apply a recursion to reach all the levels:

html.erb (so, setting the root from template):

  <% html = '' %>
  <ul>
    <li><%= root_template.id  %></li>
    <ul>
        <%= recursive_tree root_template, html %>
    </ul>
  </ul>

Then helper method:

  def recursive_tree(root, html)
    html << ''
    if !root.has_children?
      html << "<li>#{root.id}</li>"
      return html.html_safe
    else
      for template_child in root.children
        html << "<ul>#{recursive_tree(template_child, html)}</ul>"
      end
    end
    return html.html_safe
  end

Result:Wrong Recursive Result

I already spent a day to figure out how to send proper html from helper to template, now couldn't figure out what is the issue with this recursion and the solution even I used a debugger. Is there any opinion?

Improve this question
2
  • Results seem identical. What's the problem? Commented Jan 6, 2013 at 6:45
  • @HélioSantos I've corrected the first image. Commented Jan 6, 2013 at 8:28

2 Answers 2

Reset to default
3

Following is the final answers for the recursive problem that I was having above, they both share a similar template call like these:

For sol 1:

  <% html = '' %>
  <ul>
    <%= recursive_tree root_template, html %>
  </ul>

For sol 2:

  <ul>
    <%= call_me_baby_two root_template %>
  </ul>

Solution 1) Making the above problematic given code works w/o any cleaning:

  • Explanation 1) I was passing whole html code to recursive call, so it was the biggest mistake, now I pass a blank string and append it after recursive call returns to the main html, and it goes like that for deeper calls in recursion.

  • Explanation 2) I wasn't adding the root's id if it a children, I've realized this after solving the previous issue.

    def recursive_tree(root, html)
html << ''
if !root.has_children?
  html << "<li>#{root.id}</li>"
  return html.html_safe
else
  html << "<li>#{root.id}</li>" # Explanation 2
  for template_child in root.children 
    temp_html = '' # Explanation 1
    html << "<ul>#{recursive_tree(template_child, temp_html)}</ul>"
  end
end
return html.html_safe
end

Solution 2) Below I also spend extra time to make @davidrac 's pseudocode working:

  def recursive_tree_three(root)
    html=''
    if root
      html = "<li>#{root.id}</li>"
      if root.has_children?
        for template_child in root.children
          html << "<ul>"
          html << recursive_tree_three(template_child)
          html << "</ul>"
        end
      end
    end
    return html
  end

  def call_me_baby_two(root)
    recursive_tree_three(root).html_safe
  end
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

One problem I can spot here is that you use html_safe more then you need to. Since you have html_safe as part of the recursive method, it's called over and over for the deeper nodes.

Another thing that seems wrong in your implementation is that the <li> tag does not wrap the <ul> tags properly, so this will probably get wrong results for nodes with multiple children

Maybe you can construct the recursion method a bit differently (mostly pseudocode):

def recursive_tree(root)
  res = ''
  if root
    res = "<li>#{root.id}"
    # if root has children
    #   add <ul>
    #   for each of the children res << recursive_tree(child)
    #   add </ul>
    # end
    res << "</li>"
  end
  res
end

now add some wrapping function to create the initial list and add the html_safe:

wrapping_func(root)
  "<ul>#{recursive_tree(root)}</ul>".html_safe
end

BTW, it may help if you add to your question the structure you're expecting, and what is the html output.

Improve this answer

4 Comments

adding wrapper method, and removing html_safe didn't make any changes on the result. At the beginning you wrote res = '' instead of res << '', this also makes the reset the content of res every time recursion is called, so res will only have the content of the last call of depth of the recursion.
@baris, in my version, res is a local variable, and not passed to the function, so declaring it in the beginning does not override anything. Each call to the function created an internal variable and appends the result of the recursive call to it. If you'll share the changed code and the data you pass to it I can help you figure what's wrong.
One thing that seems wrong in your implementation is that the <li> tag does not wrap the <ul> tags properly, so this will probably get wrong results for nodes with multiple children.
1) Yes, I wrong! because I pass "res" to the recursive in my impl. therefore mistaken comes from there. 2)<ul> wraps the <il> there doesn't seem a problem regarding tags for me. Finally I made your pseudo plus my implementation works properly. I'll write separately. THANKS!

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.