comet-cpp 0.9.0

data/vendor/src/bindable.cpp

@@ -0,0 +1,99 @@
+#include "bindable.hpp"
+#include "globals.hpp"
+#include "from_string.hpp"
+
+using namespace Comet;
+
+Bindable& Bindable::use_mode(BindMode mode, const std::string& parameter)
+{
+  bind_mode = mode;
+  switch (mode)
+  {
+  case ThrottleBind:
+    throttle_refresh = Comet::from_string<unsigned long>(parameter);
+    break ;
+  case SignalBind:
+    signal_name = parameter;
+    break ;
+  case StaticBind:
+    break ;
+  }
+  return *this;
+}
+
+void Bindable::enable(Comet::Signal<std::string>& signal)
+{
+  enabled = true;
+  switch (bind_mode)
+  {
+  case StaticBind:
+    break ;
+  case SignalBind:
+    listen_to(signal, [this](const std::string& name) {
+      if (name == signal_name)
+        update();
+    });
+    break ;
+  case ThrottleBind:
+    enabled_ptr = std::make_shared<bool>(true);
+    throttle_schedule();
+    break ;
+  }
+  update();
+}
+
+void Bindable::disable()
+{
+  enabled = false;
+  switch (bind_mode)
+  {
+  case StaticBind:
+  case ThrottleBind:
+    (*enabled_ptr) = false;
+    break ;
+  case SignalBind:
+    stop_listening();
+    break ;
+  }
+}
+
+void Bindable::update()
+{
+  if (has_updater)
+  {
+    __asm__("try {");
+    updater();
+    __asm__("} catch(error) { console.error('[Comet] failed to update Bindable:', error); }");
+  }
+  else if (!element.is_undefined())
+  {
+    if (target == "text")
+      element.text(get_value());
+    else
+      element.attr(target, get_value());
+  }
+}
+
+std::string Bindable::get_value() const
+{
+  std::string value;
+
+  __asm__("try {");
+  value = getter();
+  __asm__("} catch (err) { console.warn('failed to update attribute', err); }");
+  return value;
+}
+
+void Bindable::throttle_schedule()
+{
+  std::shared_ptr<bool> _enabled_ptr = enabled_ptr;
+
+  Comet::window.set_timeout([this, _enabled_ptr]()
+  {
+    if (*_enabled_ptr)
+    {
+      update();
+      throttle_schedule();
+    }
+  }, throttle_refresh);
+}

data/vendor/src/bindable.hpp

@@ -0,0 +1,106 @@
+#ifndef  COMET_BINDABLE_HPP
+# define COMET_BINDABLE_HPP
+
+# include "signal.hpp"
+# include "element.hpp"
+
+namespace Comet
+{
+  struct IBindableView : public Comet::Element
+  {
+    IBindableView() : Comet::Element("div") {}
+    IBindableView(const client::String& tagName) : Comet::Element(tagName) {}
+
+    virtual void bind_attributes() = 0;
+    virtual void trigger_binding_updates() = 0;
+  private:
+    IBindableView(const IBindableView&) {}
+  };
+
+  struct BindableUpdater
+  {
+    std::function<void()> func;
+
+    void execute()
+    {
+      if (func)
+        func();
+      else
+        el.attr(target, getter());
+    }
+
+    Comet::Element el;
+    const std::string target;
+    std::function<std::string (void)> getter;
+  };
+
+  class Bindable : public Comet::Listener
+  {
+  public:
+    typedef std::function<std::string (void)> Getter;
+
+    enum BindMode
+    {
+      StaticBind,
+      SignalBind,
+      ThrottleBind
+    };
+
+  private:
+    BindMode               bind_mode = StaticBind;
+    Comet::Element element;
+    std::string            target;
+    Getter                 getter;
+    bool                   has_updater = false;
+    std::function<void()>  updater;
+
+    std::string            signal_name;
+    unsigned long          throttle_refresh;
+    bool                   enabled = false;
+    std::shared_ptr<bool>  enabled_ptr;
+
+  public:
+    Bindable() {}
+    Bindable(Comet::Element el, const std::string& t, Getter g) : element(el), target(t), getter(g) {}
+    Bindable(std::function<void ()> func) : has_updater(true), updater(func) {}
+
+    ~Bindable() { disable(); }
+
+    inline Bindable& bind_to(Comet::Element el) { element = el; return *this; }
+    inline Bindable& on_attribute(const std::string& t, Getter g) { target = t; getter = g; return *this; }
+    Bindable& use_mode(BindMode, const std::string& parameter);
+
+    void enable(Comet::Signal<std::string>& signal);
+    void disable();
+    void update();
+
+  private:
+    std::string get_value() const;
+    void throttle_schedule();
+  };
+
+  class BoundAttributes : public std::vector<Bindable>
+  {
+  public:
+    void update()
+    {
+      for (Bindable& bindable : *this)
+        bindable.update();
+    }
+
+    void enable(Comet::Signal<std::string>& signaler)
+    {
+      disable();
+      for (Bindable& bindable : *this)
+        bindable.enable(signaler);
+    }
+
+    void disable()
+    {
+      for (Bindable& bindable : *this)
+        bindable.disable();
+    }
+  };
+}
+
+#endif

data/vendor/src/cheerp_parse_cookie_values.cpp

@@ -0,0 +1,58 @@
+#include "parse_cookie_values.hpp"
+#include "url.hpp"
+#include <regex>
+#include <iostream>
+
+using namespace std;
+
+static bool trigger_add_cookie_value(const string& str, std::function<bool (const string&, const string&)> callback, size_t key_start, size_t key_end, size_t val_start, size_t val_end)
+{
+  string key = str.substr(key_start, key_end - key_start);
+  string val = str.substr(val_start, val_end - val_start);
+  key = Comet::Url::decode(key);
+  val = Comet::Url::decode(val);
+  return callback(key, val);
+}
+
+namespace Comet
+{
+  void parse_cookie_values(const string& str, std::function<bool (const std::string&, const std::string&)> callback)
+  {
+    char   state = 0;
+    size_t key_start = 0;
+    size_t key_end = 0;
+    size_t val_start = 0;
+
+    for (size_t i = 0 ; i < str.size() ; ++i)
+    {
+      switch (state)
+      {
+        case 0: // spaces
+          if (str[i] == ' ') continue ;
+          key_start = i;
+          state++;
+        case 1: // key
+          if (str[i] == '=')
+          {
+            key_end = i;
+            val_start = i + 1;
+            state++;
+          }
+          break ;
+        case 2: // value
+          if (str[i] == ';')
+          {
+            state = 0;
+            if (!(trigger_add_cookie_value(str, callback,
+               key_start, key_end, val_start, i)))
+              return ;
+          }
+      }
+    }
+    if (state == 2)
+    {
+      trigger_add_cookie_value(str, callback,
+        key_start, key_end, val_start, str.size());
+    }
+  }
+}

data/vendor/src/comment_element.cpp

@@ -0,0 +1,11 @@
+#include "comment_element.hpp"
+#include "globals.hpp"
+
+using namespace Comet;
+
+client::HTMLElement* CommentElement::makeCommentElement(const client::String& str)
+{
+  client::Comment* comment = Comet::document->createComment(str);
+
+  return reinterpret_cast<client::HTMLElement*>(comment);
+}

data/vendor/src/comment_element.hpp

@@ -0,0 +1,17 @@
+#ifndef  COMET_COMMENT_ELEMENT_HPP
+# define COMET_COMMENT_ELEMENT_HPP
+
+# include "element.hpp"
+
+namespace Comet
+{
+  class CommentElement : public Comet::Element
+  {
+    static client::HTMLElement* makeCommentElement(const client::String&);
+  public:
+    CommentElement(const client::String& str) : Element(makeCommentElement(str)) {}
+    CommentElement() : Element(makeCommentElement("")) {}
+  };
+}
+
+#endif

data/vendor/src/cookies.cpp

@@ -0,0 +1,94 @@
+#include "cookies.hpp"
+#include "exception.hpp"
+#include "object.hpp"
+#include "url.hpp"
+#include "parse_cookie_values.hpp"
+#include <cheerp/client.h>
+#include <cheerp/clientlib.h>
+
+using namespace Comet;
+using namespace std;
+
+Comet::Cookies cookies;
+
+bool Cookies::has(const string& key)
+{
+  ensure_cookie_map_is_updated();
+  return cookie_store.find(key) != cookie_store.end();
+}
+
+template<>
+string Cookies::get<string>(const string& key)
+{
+  ensure_cookie_map_is_updated();
+  if (!has(key))
+    Comet::raise(std::runtime_error("cookie `" + key + "` does not exist"));
+  return cookie_store.at(key);
+}
+
+template<>
+void Cookies::set<string>(const string& key, const string& val)
+{
+  ensure_cookie_map_is_updated();
+  if (has(key))
+    cookie_store.at(key) = val;
+  else
+    cookie_store.insert(pair<string, string>(key, val));
+  set_cookie_string(
+    Url::encode(key) + '=' + Url::encode(val)
+  );
+}
+
+template<>
+void Cookies::set<string>(const string& key, const string& val, time_t expires_in)
+{
+  string time_string;
+
+  ensure_cookie_map_is_updated();
+  if (has(key))
+    cookie_store.at(key) = val;
+  else
+    cookie_store.insert(pair<string, string>(key, val));
+  if (expires_in > 0)
+  {
+    ObjectImpl<client::Date> date;
+    double expires_time = date->getTime() + expires_in * 1000;
+
+    date->setTime(expires_time);
+    time_string = "; expires=" + (string)date.apply("toGMTString");
+  }
+  set_cookie_string(
+    Url::encode(key) + '=' + Url::encode(val) + time_string
+  );
+}
+
+void Cookies::remove(const string& key)
+{
+  ensure_cookie_map_is_updated();
+  cookie_store.erase(key);
+  set_cookie_string(
+    Url::encode(key) + "=null; expires=Sat, 05 Nov 2016 00:00:00 GMT"
+  );
+  last_cookie_string = get_cookie_string();
+}
+
+void Cookies::update_cookie_map()
+{
+  last_cookie_string = get_cookie_string();
+  cookie_store.clear();
+  Comet::parse_cookie_values(last_cookie_string,
+    [this](const string& key, const string& value) {
+    cookie_store.emplace(key, value);
+    return true;
+  });
+}
+
+string Cookies::get_cookie_string() const
+{
+  return (string)(*client::document.get_cookie());
+}
+
+void Cookies::set_cookie_string(const string& str) const
+{
+  client::document.set_cookie(str.c_str());
+}

data/vendor/src/cookies.hpp

@@ -0,0 +1,60 @@
+#ifndef  CRAILS_FRONT_COOKIES_HPP
+# define CRAILS_FRONT_COOKIES_HPP
+
+# include "from_string.hpp"
+# include <string>
+# include <map>
+# include <ctime>
+
+namespace Comet
+{
+  class Cookies
+  {
+    typedef std::map<std::string, std::string> CookieMap;
+  public:
+    bool        has(const std::string& key);
+    void        remove(const std::string& key);
+
+    template<typename TYPE>
+    TYPE get(const std::string& key)
+    {
+      std::string val = get<std::string>(key);
+
+      return Comet::from_string<TYPE>(val);
+    }
+
+    template<typename TYPE>
+    void set(const std::string& key, const TYPE& val)
+    {
+      set(key, std::to_string(val), 0);
+    }
+
+    template<typename TYPE>
+    void set(const std::string& key, const TYPE& val, std::time_t expires_in)
+    {
+      set(key, std::to_string(val), expires_in);
+    }
+
+  private:
+    std::string get_cookie_string() const;
+    void        set_cookie_string(const std::string&) const;
+
+    inline void ensure_cookie_map_is_updated()
+    {
+      if (last_cookie_string != get_cookie_string())
+        update_cookie_map();
+    }
+
+    void update_cookie_map();
+
+    CookieMap   cookie_store;
+    std::string last_cookie_string;
+  };
+
+  template<>
+  std::string Cookies::get<std::string>(const std::string& key);
+  template<>
+  void Cookies::set(const std::string& key, const std::string& val, std::time_t);
+}
+
+#endif

data/vendor/src/custom_element.hpp

@@ -0,0 +1,61 @@
+#ifndef  COMET_HTML_TEMPLATE_HPP
+# define COMET_HTML_TEMPLATE_HPP
+
+# include "bindable.hpp"
+# include "element.hpp"
+
+namespace Comet
+{
+  class BindableEngineCommon : public IBindableView
+  {
+  protected:
+    Comet::BoundAttributes bound_attributes;
+    virtual Comet::Signal<std::string>& get_signaler() = 0;
+
+  public:
+    BindableEngineCommon(const client::String& tagName) : IBindableView(tagName) {}
+    BindableEngineCommon() {}
+
+    virtual void bind_attributes()
+    {
+      bound_attributes.enable(get_signaler());
+    }
+
+    virtual void trigger_binding_updates()
+    {
+      bound_attributes.update();
+    }
+  };
+
+  class BindableEngine : public BindableEngineCommon
+  {
+  public:
+    BindableEngine(const client::String& tagName) : BindableEngineCommon(tagName) {}
+    BindableEngine() {}
+
+    Comet::Signal<std::string> signaler;
+  protected:
+    Comet::Signal<std::string>& get_signaler() { return signaler; }
+
+  };
+
+  class BindableEngineClient : public BindableEngineCommon
+  {
+  public:
+    BindableEngineClient(const client::String& tagName, Comet::Signal<std::string>& s) : BindableEngineCommon(tagName), signaler(s) {}
+    BindableEngineClient(Comet::Signal<std::string>& s) : signaler(s) {}
+
+    Comet::Signal<std::string>& signaler;
+  protected:
+    Comet::Signal<std::string>& get_signaler() { return signaler; }
+  };
+
+  class CustomElement : public BindableEngine
+  {
+  public:
+    CustomElement(const client::String& tagName) : BindableEngine(tagName) {}
+    CustomElement() {}
+  };
+}
+
+#endif

data/vendor/src/datatree.cpp

@@ -0,0 +1,198 @@
+#include "datatree.hpp"
+#include "globals.hpp"
+#include "exception.hpp"
+#include <iostream>
+
+using namespace std;
+
+DataTree& DataTree::from_json(stringstream& stream)
+{
+  return from_json(stream.str());
+}
+
+DataTree& DataTree::from_json(const string& str)
+{
+  Comet::String js_str(str);
+
+  tree = Comet::Object::from_json(*js_str);
+  return *this;
+}
+
+DataTree& DataTree::from_json_file(const string&)
+{
+  Comet::raise(std::logic_error("DataTree::from_json_file not available from Comet.cpp"));
+  return *this;
+}
+
+string DataTree::to_json() const
+{
+  return tree.to_json();
+}
+
+void Data::each(function<bool (Data)> functor)
+{
+  for (auto _key : get_keys())
+  {
+    Data data(as_object(), _key);
+
+    if (!(functor(data)))
+      break ;
+  }
+}
+
+void Data::each(function<bool (const Data)> functor) const
+{
+  for (auto _key : get_keys())
+  {
+    const Data data(as_object(), _key);
+
+    if (!(functor(data)))
+      break ;
+  }
+}
+
+Data Data::at(unsigned int i) const
+{
+  std::stringstream stream;
+  std::string stringified;
+
+  stream << i;
+  stream >> stringified;
+  return Data(as_object(), stringified);
+}
+
+bool Data::exists() const
+{
+  if (key.length())
+  {
+    Comet::String js_key(key);
+
+    return object->hasOwnProperty(*js_key);
+  }
+  return true;
+}
+
+bool Data::is_blank() const
+{
+  return !exists() || as<string>() == "";
+}
+
+bool Data::is_null() const
+{
+  return !exists() || as<string>() == "null";
+}
+
+vector<string> Data::get_keys() const
+{
+  return Comet::window["Object"].apply("keys", as_object());
+}
+
+vector<string> Data::find_missing_keys(const vector<string>& keys) const
+{
+  vector<string> missing_keys;
+  string         path_prefix;
+
+  for (string key : keys)
+  {
+    Comet::String js_key(key);
+
+    if (!(as_object()->hasOwnProperty(*js_key)))
+      missing_keys.push_back(key);
+  }
+  return missing_keys;
+}
+
+bool Data::require(const vector<string>& keys) const
+{
+  return find_missing_keys(keys).size() == 0;
+}
+
+bool Data::is_array() const
+{
+  return *(as_object()["constructor"]) == *(Comet::window["Array"]);
+}
+
+void Data::merge(Data data)
+{
+  if (data.exists())
+  {
+    if (key.length() > 0)
+    {
+     if (data.is_array())
+        object.set(key, data.as_object().apply("slice", 0));
+      else
+        object.set(key, Comet::Object::from_json(data.as_object().to_json()));
+    }
+    else
+    {
+      for (const auto& key : data.get_keys())
+        (*this)[key].merge(data[key]);
+    }
+  }
+}
+
+void Data::merge(DataTree datatree)
+{
+  merge(datatree.as_data());
+}
+
+void Data::output(ostream& out) const
+{
+  out << to_json();
+}
+
+string Data::to_json() const
+{
+  return as_object().to_json();
+}
+
+string Data::to_xml() const
+{
+  Comet::raise(std::logic_error("Data::to_xml not available from Comet.cpp"));
+  return "";
+}
+
+size_t Data::count() const
+{
+  if (is_array())
+    return as_object()["length"];
+  return get_keys().size();
+}
+
+void Data::destroy()
+{
+  if (key.length() > 0)
+    object.unset(key);
+  else
+  {
+    for (auto subkey : get_keys())
+      object.unset(subkey);
+  }
+}
+
+template<>
+bool Data::as<bool>() const
+{
+  std::string as_string = as_object().apply("toString");
+  std::stringstream stream;
+  int numerical_value;
+
+  if (as_string == "true" || as_string == "false")
+    return as_string == "true";
+  stream << as_string;
+  stream >> numerical_value;
+  return numerical_value != 0;
+}
+
+template<>
+string Data::as<string>() const
+{
+  return as_object().apply("toString");
+}
+
+
+template<>
+wstring Data::as<wstring>() const
+{
+  return as_object().apply("toString");
+}