From 213d7bae1233185595186f881a150ee238dac64f Mon Sep 17 00:00:00 2001
From: Adam Dickmeiss <adam@indexdata.dk>
Date: Tue, 25 Jun 2013 16:47:02 +0200
Subject: [PATCH 1/1] Deciding rules for within

Not really tested yet.
---
 src/filter_http_rewrite.cpp |  123 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 120 insertions(+), 3 deletions(-)

diff --git a/src/filter_http_rewrite.cpp b/src/filter_http_rewrite.cpp
index 098c349..9d672fb 100644
--- a/src/filter_http_rewrite.cpp
+++ b/src/filter_http_rewrite.cpp
@@ -28,6 +28,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include <boost/regex.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
 
 #include <map>
 
@@ -76,7 +77,6 @@ namespace metaproxy_1 {
                 std::map<std::string, std::string> & vars) const;
         };
         class HttpRewrite::Event : public HTMLParserEvent {
-        public:
             void openTagStart(const char *name);
             void anyTagEnd(const char *name);
             void attribute(const char *tagName, 
@@ -85,6 +85,13 @@ namespace metaproxy_1 {
                            int val_len);
             void closeTag(const char *name);
             void text(const char *value, int len);
+            const Phase *m_phase;
+            WRBUF m_w;
+            std::list<Within>::const_iterator enabled_within;
+        public:
+            Event(const Phase *p);
+            ~Event();
+            const char *result();
         };
     }
 }
@@ -208,10 +215,14 @@ void yf::HttpRewrite::Phase::rewrite_body(mp::odr & o,
     if (*content_buf)
     {
         HTMLParser parser;
-        Event ev;
+        Event ev(this);
         std::string buf(*content_buf, *content_len);
 
         parser.parse(ev, buf.c_str());
+        std::cout << "RES\n" << ev.result() << std::endl;
+        std::cout << "-----" << std::endl;
+
+
         std::list<Within>::const_iterator it = within_list.begin();
         if (it != within_list.end())
         {
@@ -228,13 +239,52 @@ void yf::HttpRewrite::Phase::rewrite_body(mp::odr & o,
     }
 }
 
+yf::HttpRewrite::Event::Event(const Phase *p) : m_phase(p)
+{
+    m_w = wrbuf_alloc();
+    enabled_within = m_phase->within_list.end();
+}
+
+yf::HttpRewrite::Event::~Event()
+{
+    wrbuf_destroy(m_w);
+}
+
+const char *yf::HttpRewrite::Event::result()
+{
+    return wrbuf_cstr(m_w);
+}
 
 void yf::HttpRewrite::Event::openTagStart(const char *name)
 {
+    // check if there is <within tag="x" .. />
+    if (enabled_within == m_phase->within_list.end())
+    {
+        std::list<Within>::const_iterator it =
+            m_phase->within_list.begin();
+        for (; it != m_phase->within_list.end(); it++)
+        {
+            if (it->tag.length() > 0 && it->tag.compare(name) == 0)
+            {
+                enabled_within = it;
+            }
+        }
+    }
+    wrbuf_putc(m_w, '<');
+    wrbuf_puts(m_w, name);
 }
 
 void yf::HttpRewrite::Event::anyTagEnd(const char *name)
 {
+    std::list<Within>::const_iterator it = enabled_within;
+    if (it != m_phase->within_list.end())
+    {
+        if (it->tag.compare(name) == 0)
+        {
+            enabled_within = m_phase->within_list.end();
+        }
+    }
+    wrbuf_putc(m_w, '>');
 }
 
 void yf::HttpRewrite::Event::attribute(const char *tagName,
@@ -242,15 +292,82 @@ void yf::HttpRewrite::Event::attribute(const char *tagName,
                                          const char *value,
                                          int val_len)
 {
-}
+    std::list<Within>::const_iterator it = enabled_within;
+    bool subst = false;
 
+    if (it == m_phase->within_list.end())
+    {
+        // no active within tag.. see if a attr rule without tag applies
+        it = m_phase->within_list.begin();
+        for (; it != m_phase->within_list.end(); it++)
+        {
+            if (it->attr.length() > 0 && it->tag.length() == 0)
+                break;
+        }
+    }
+    if (it != m_phase->within_list.end())
+    {
+        std::vector<std::string> attr;
+        boost::split(attr, it->attr, boost::is_any_of(","));
+        size_t i;
+        for (i = 0; i < attr.size(); i++)
+        {
+            if (attr[i].compare("#text") && attr[i].compare(tagName) == 0)
+            {
+                subst = true;
+            }
+        }
+    }
+
+    wrbuf_putc(m_w, ' ');
+    wrbuf_puts(m_w, name);
+    wrbuf_puts(m_w, "\"");
+    wrbuf_write(m_w, value, val_len);
+    if (subst)
+        wrbuf_puts(m_w, " SUBST");
+    wrbuf_puts(m_w, "\"");
+}
 
 void yf::HttpRewrite::Event::closeTag(const char *name)
 {
+    std::list<Within>::const_iterator it = enabled_within;
+    if (it != m_phase->within_list.end())
+    {
+        if (it->tag.compare(name) == 0)
+        {
+            enabled_within = m_phase->within_list.end();
+        }
+    }
+    wrbuf_puts(m_w, "</");
+    wrbuf_puts(m_w, name);
 }
 
 void yf::HttpRewrite::Event::text(const char *value, int len)
 {
+    std::list<Within>::const_iterator it = enabled_within;
+    bool subst = false;
+
+    if (it != m_phase->within_list.end())
+    {
+        subst = true;
+        if (it->attr.length() > 0)
+        {
+            subst = false;
+            std::vector<std::string> attr;
+            boost::split(attr, it->attr, boost::is_any_of(","));
+            size_t i;
+            for (i = 0; i < attr.size(); i++)
+            {
+                if (attr[i].compare("#text") == 0)
+                {
+                    subst = true;
+                }
+            }
+        }
+    }
+    wrbuf_write(m_w, value, len);
+    if (subst)
+        wrbuf_puts(m_w, "<!-- SUBST -->");
 }
 
 
-- 
1.7.10.4