comet-cpp 0.9.0

data/vendor/src/datatree.hpp

@@ -0,0 +1,233 @@
+#ifndef  FRONT_DATATREE_HPP
+# define FRONT_DATATREE_HPP
+
+# include <functional>
+# include <vector>
+# include <string>
+# include <iostream>
+# include <sstream>
+# include "object.hpp"
+# include <iostream>
+
+class DataTree;
+
+class Data
+{
+  friend class DataTree;
+protected:
+  Data(Comet::Object o) : object(o)
+  {
+  }
+
+  Data(Comet::Object o, const std::string& k) : object(o), key(k)
+  {
+  }
+
+public:
+  Data() : object(Comet::Object())
+  {
+  }
+
+  template<typename T>
+  T operator[](const std::string& key) const
+  {
+    std::string as_string = as_object()[key.c_str()];
+    std::stringstream stream;
+    T output;
+
+    stream << as_string;
+    stream >> output;
+    return output;
+  }
+
+  Data operator[](const std::string& k) const
+  {
+    if (is_null())
+      object.set(key, Comet::Object());
+    return Data(as_object(), k.c_str());
+  }
+
+  template<typename T>
+  T operator[](const char* str) const { return operator[]<T>(std::string(str)); }
+  Data operator[](const char* str) const { return operator[](std::string(str)); }
+
+  Data at(unsigned int i) const;
+
+  std::vector<std::string> find_missing_keys(const std::vector<std::string>& keys) const;
+  bool require(const std::vector<std::string>& keys) const;
+
+  const std::string& get_path() const { return key; }
+  const std::string& get_key()  const { return key; }
+
+  std::size_t count() const;
+
+  template<typename T>
+  T as() const
+  {
+    std::string as_string = as_object().apply("toString");
+    std::stringstream stream;
+    T value;
+
+    stream << as_string;
+    stream >> value;
+    return value;
+  }
+
+  template<typename T>
+  T defaults_to(const T def) const { return exists() ? as<T>() : def; }
+
+  template<typename T>
+  operator T() const
+  {
+    return as<T>();
+  }
+
+  template<typename T>
+  std::vector<T> to_vector() const
+  {
+    return as_object().to_vector<T>();
+  }
+
+  template<typename T>
+  void from_vector(const std::vector<T>& array)
+  {
+    Comet::ObjectImpl<client::Array> array_object;
+
+    for (const T& v : array)
+    {
+      Comet::Object value_object(v);
+
+      array_object->push(*value_object);
+    }
+    object.set(key, array_object);
+  }
+
+  template<typename T>
+  operator std::vector<T>() const
+  {
+    return to_vector<T>();
+  }
+
+  template<typename T>
+  Data& operator=(const T value)
+  {
+    Comet::Object value_object(value);
+
+    object.set(key, value_object);
+    return *this;
+  }
+
+  template<typename T>
+  Data& operator=(const std::vector<T>& value)
+  {
+    from_vector(value);
+    return *this;
+  }
+
+  Data& operator=(const Data& copy)
+  {
+    object = copy.object;
+    key    = copy.key;
+    return *this;
+  }
+
+  template<typename T>
+  bool operator==(const T value) const
+  {
+    T self = as_object();
+
+    return self == value;
+  }
+
+  template<typename T>
+  bool operator!=(const T value) const { return !(Data::operator==(value)); }
+
+  Data operator||(Data value) const
+  {
+    return exists() ? *this : value;
+  }
+
+  template<typename T>
+  T operator||(const T value) const
+  {
+    return defaults_to<T>(value);
+  }
+
+  void push_back(Data data)
+  {
+    if (!(exists()))
+      object.set(key, Comet::ObjectImpl<client::Array>());
+    Comet::ObjectImpl<client::Array> array(*as_object());
+
+    array->push(*data.as_object());
+  }
+
+  template<typename T>
+  void push_back(const T value)
+  {
+    if (!(exists()))
+      object.set(key, Comet::ObjectImpl<client::Array>());
+    Comet::ObjectImpl<client::Array> array(*as_object());
+    Comet::Object value_object(value);
+
+    array->push(*value_object);
+  }
+
+  bool is_null() const;
+  bool is_blank() const;
+  bool is_array() const;
+  bool exists() const;
+  void destroy();
+
+  void each(std::function<bool (Data)> functor);
+  void each(std::function<bool (const Data)> functor) const;
+
+  void output(std::ostream& out = std::cout) const;
+  std::string to_json() const;
+  std::string to_xml() const;
+
+  void merge(Data data);
+  void merge(DataTree datatree);
+
+  Comet::Object as_object() const
+  {
+    if (key.length() == 0)
+      return object;
+    return object[key.c_str()];
+  }
+
+  std::vector<std::string> get_keys() const;
+
+  mutable Comet::Object object;
+  std::string                   key;
+};
+
+template<> bool Data::as<bool>() const;
+template<> std::string Data::as<std::string>() const;
+template<> std::wstring Data::as<std::wstring>() const;
+
+class DataTree
+{
+public:
+  DataTree() {}
+  DataTree(Comet::Object o) : tree(o) {}
+
+  operator   Data()                                   { return as_data();  }
+  Data       as_data()                                { return Data(tree); }
+  const Data as_data() const                          { return Data(tree); }
+  Data       operator[](const std::string& key)       { return Data(tree, key.c_str()); }
+  const Data operator[](const std::string& key) const { return Data(tree, key.c_str()); }
+  void       clear()                                  { tree = Comet::Object(); }
+
+  DataTree& from_json(std::stringstream& stream);
+  DataTree& from_json(const std::string& str);
+  DataTree& from_json_file(const std::string&);
+  std::string to_json() const;
+
+  Comet::Object as_object() { return tree; }
+
+private:
+  Comet::Object tree;
+};
+
+#endif

data/vendor/src/document.cpp

@@ -0,0 +1,62 @@
+#include "document.hpp"
+#include "globals.hpp"
+#include <iostream>
+
+using namespace Comet;
+using namespace std;
+
+Comet::Document Comet::document;
+
+Document::Document() : ObjectImpl(&(client::document)), events(make_shared<JavascriptEvents>((client::EventTarget*)&client::document))
+{
+  auto callback = [this]() { on_ready_state_changed(); };
+
+  events->on("readystatechange", callback);
+  client::window.setTimeout(cheerp::Callback(callback), 0);
+}
+
+Document::ReadyState Document::get_ready_state()
+{
+  client::String* str = (*this)->get_readyState();
+  std::string ready_state = (std::string)(*(str));
+
+  if (ready_state == "complete")
+    return Complete;
+  else if (ready_state == "interactive")
+    return Interactive;
+  return Loading;
+}
+
+void Document::on_ready(function<void ()> callback)
+{
+  switch (get_ready_state())
+  {
+  case Loading:
+    on_ready_callbacks.push_back(callback);
+    break ;
+  default:
+    client::window.setTimeout(cheerp::Callback(callback), 0);
+    break ;
+  }
+}
+
+void Document::on_ready_state_changed()
+{
+  switch (get_ready_state())
+  {
+  case Interactive:
+  case Complete:
+    on_loading_ended();
+    break ;
+  default:
+    break ;
+  }
+}
+
+void Document::on_loading_ended()
+{
+  body = Element((*this)->get_body());
+  for (auto callback : on_ready_callbacks)
+    callback();
+  on_ready_callbacks.empty();
+}

data/vendor/src/document.hpp

@@ -0,0 +1,31 @@
+#ifndef  COMET_DOCUMENT_HPP
+# define COMET_DOCUMENT_HPP
+
+# include "object.hpp"
+# include "signal.hpp"
+# include "events.hpp"
+# include <list>
+
+namespace Comet
+{
+  class Document : public ObjectImpl<client::Document>
+  {
+  public:
+    enum ReadyState { Loading, Interactive, Complete };
+
+    std::shared_ptr<JavascriptEvents> events;
+
+    Document();
+
+    ReadyState get_ready_state();
+    void on_ready(std::function<void ()> callback);
+
+  private:
+    void on_ready_state_changed();
+    void on_loading_ended();
+
+    std::list<std::function<void()>> on_ready_callbacks;
+  };
+}
+
+#endif

data/vendor/src/element.cpp

@@ -0,0 +1,358 @@
+#include "element.hpp"
+#include "object.hpp"
+#include <algorithm>
+
+using namespace std;
+using namespace Comet;
+
+static std::map<std::string, std::string> display_style_by_tag = {
+  {"div", "block"}, {"tr", "table-row"}, {"td", "table-cell"}, {"th", "table-cell"}, {"table", "table"}
+};
+
+static std::string get_default_display_style_for_tag(std::string tag)
+{
+  transform(tag.begin(), tag.end(), tag.begin(), [](char c) -> char { return tolower(c); });
+  if (display_style_by_tag.find(tag) != display_style_by_tag.end())
+    return display_style_by_tag.at(tag);
+   return "inline-block";
+}
+
+static std::vector<std::string> string_split(const std::string& src, char delimiter)
+{
+  vector<string> strings;
+  istringstream  f(src.c_str());
+  string         s;
+
+  while (getline(f, s, delimiter))
+    strings.push_back(s);
+  return strings;
+}
+
+Element::Element() : ObjectImpl(client::document.createElement("div")), events(make_shared<JavascriptEvents>(static_cast<client::HTMLElement*>(ptr)))
+{
+}
+
+Element::Element(const client::String& type, const map<string, string>& children) :
+  ObjectImpl(client::document.createElement(type)), events(make_shared<JavascriptEvents>(static_cast<client::HTMLElement*>(ptr)))
+{
+  attr(children);
+}
+
+Element::Element(client::HTMLElement* el) : ObjectImpl(el), events(make_shared<JavascriptEvents>(static_cast<client::HTMLElement*>(ptr)))
+{
+}
+
+void Element::destroy()
+{
+  if (has_parent())
+    (*this)->get_parentElement()->removeChild(**this);
+}
+
+bool Element::is_visible() const
+{
+  auto* style       = (*this)->get_style();
+  auto* css_display = style->get_display();
+  auto* css_visible = style->get_visibility();
+
+  return (!css_display || (string)(*css_display) != "none") &&
+         (!css_visible || (string)(*css_visible) != "hidden");
+}
+
+Element& Element::visible(bool value, const string& _display)
+{
+  auto*  style = (*this)->get_style();
+  string display;
+
+  if (value)
+  {
+    if (!_display.length())
+      display = get_default_display_style_for_tag(tagName());
+    else
+      display = _display;
+  }
+  else
+    display = "none";
+  style->set_display(display.c_str());
+  return *this;
+}
+
+bool Element::is_attached() const
+{
+  auto* el = (*this)->get_parentElement();
+
+  while (el)
+  {
+    if (el == client::document.get_body())
+      return true;
+    el = el->get_parentElement();
+  }
+  return false;
+}
+
+bool Element::has_parent() const
+{
+  return (*this)->get_parentElement() != 0;
+}
+
+Element Element::get_parent()
+{
+  return Element((*this)->get_parentElement());
+}
+
+Element Element::get_next()
+{
+  return Element((client::HTMLElement*)((*this)->get_nextElementSibling()));
+}
+
+Element& Element::attr(const std::map<std::string, std::string>& attrs)
+{
+  for (auto it = attrs.begin() ; it != attrs.end() ; ++it)
+   (*this)->setAttribute(it->first.c_str(), it->second.c_str());
+  return *this;
+}
+
+Element& Element::attr(const std::map<std::string, std::wstring>& attrs)
+{
+  for (auto it = attrs.begin() ; it != attrs.end() ; ++it)
+   (*this)->setAttribute(it->first.c_str(), it->second.c_str());
+  return *this;
+}
+
+Element& Element::attr(const std::map<std::string, client::String*>& attrs)
+{
+  for (auto it = attrs.begin() ; it != attrs.end() ; ++it)
+   (*this)->setAttribute(it->first.c_str(), it->second);
+  return *this;
+}
+
+Element& Element::attr(const string& name, const string& value)
+{
+  (*this)->setAttribute(name.c_str(), value.c_str());
+  return *this;
+}
+
+string Element::attr(const string& name) const
+{
+  if ((*this)->hasAttribute(name.c_str()))
+  {
+    Comet::Object attribute = (*this)->getAttribute(name.c_str());
+
+    return attribute;
+  }
+  return "";
+}
+
+static std::string generate_style_attribute(std::map<std::string, std::string> attrs)
+{
+  std::string result;
+
+  for (auto entry : attrs)
+    result += entry.first + ':' + entry.second + ';';
+  return result;
+}
+
+Element& Element::css(const string& name, const string& value)
+{
+  auto css_attributes = css();
+
+  css_attributes[name] = value;
+  attr("style", generate_style_attribute(css_attributes));
+  return *this;
+}
+
+Element& Element::css(const map<string,string>& attrs)
+{
+  auto css_attributes = css();
+
+  for (auto entry : attrs)
+    css_attributes[entry.first] = entry.second;
+  attr("style", generate_style_attribute(css_attributes));
+  return *this;
+}
+
+map<string, string> Element::css() const
+{
+  map<string, string> results;
+  string style = attr("style");
+  auto   css_attributes = string_split(style, ';');
+
+  for (auto css_attribute : css_attributes)
+  {
+    auto delimiter = css_attribute.find(':');
+
+    if (delimiter != string::npos)
+      results.emplace(css_attribute.substr(0, delimiter), css_attribute.substr(delimiter + 1));
+  }
+  return results;
+}
+
+void Element::append_to(client::HTMLElement* el)
+{
+  el->appendChild(**this);
+}
+
+void Element::append_to(Element& el)
+{
+  el->appendChild(static_cast<client::HTMLElement*>(ptr));
+}
+
+void Element::insert_before(client::HTMLElement* el)
+{
+  if (el)
+  {
+    auto* parent = el->get_parentElement();
+
+    if (parent)
+      parent->insertBefore(**this, el);
+  }
+}
+
+void Element::insert_before(Element& el)
+{
+  insert_before(static_cast<client::HTMLElement*>(el.ptr));
+}
+
+void Element::insert_after(client::HTMLElement* el)
+{
+  if (el)
+  {
+    Comet::Element wrapper(el);
+    auto* nextSibling = el->get_nextSibling();
+
+    if (nextSibling)
+      insert_before(static_cast<client::HTMLElement*>(nextSibling));
+    else if (wrapper.has_parent())
+      append_to(*(wrapper.get_parent()));
+  }
+}
+
+void Element::insert_after(Element& el)
+{
+  insert_after(static_cast<client::HTMLElement*>(el.ptr));
+}
+
+bool Element::contains(const client::HTMLElement* source)
+{
+  bool result = false;
+
+  if (**this == source)
+    return true;
+  each([&result, source](Element& el) -> bool
+  {
+    result = el.contains(source);
+    return !result;
+  });
+  return result;
+}
+
+std::vector<Element> Element::find(const std::string& selector)
+{
+  client::NodeList* node_list = (*this)->querySelectorAll(selector.c_str());
+  std::vector<Element> results;
+
+  results.resize(node_list->get_length());
+  for (double i = 0 ; i < node_list->get_length() ; ++i)
+    results[i] = Element(static_cast<client::HTMLElement*>(node_list->item(i)));
+  return results;
+}
+
+Element Element::find_one(const std::string& selector)
+{
+  return Element(static_cast<client::HTMLElement*>((*this)->querySelector(selector.c_str())));
+}
+
+void Element::each(std::function<bool (Element&)> func)
+{
+  auto* node_list = (*this)->get_childNodes();
+
+  for (double i = 0 ; i < node_list->get_length() ; ++i)
+  {
+    Element child(static_cast<client::HTMLElement*>(node_list->item(i)));
+
+    if (func(child) == false)
+      break ;
+  }
+}
+
+Element& Element::empty()
+{
+  auto* node_list = (*this)->get_childNodes();
+
+  while (node_list->get_length())
+  {
+    (*this)->removeChild(node_list->item(0));
+    node_list = (*this)->get_childNodes();
+  }
+  return *this;
+}
+
+void Element::toggle_class(const std::string& str, bool set)
+{
+  if (has_class(str))
+  {
+    if (!set)
+      remove_class(str);
+  }
+  else if (set)
+    add_class(str);
+}
+
+void Element::add_class(const std::string& str)
+{
+  auto* class_list = (*this)->get_classList();
+
+  class_list->add(str.c_str());
+}
+
+void Element::remove_class(const std::string& str)
+{
+  auto* class_list = (*this)->get_classList();
+
+  class_list->remove(str.c_str());
+}
+
+bool Element::has_class(const std::string& str) const
+{
+  auto* class_list = (*this)->get_classList();
+
+  return class_list->contains(str.c_str());
+}
+
+bool Element::has_attribute(const std::string& key) const
+{
+  return (*this)->hasAttribute(key.c_str());
+}
+
+std::string Element::get_attribute(const std::string& key) const
+{
+  client::String* attr_ptr = (*this)->getAttribute(key.c_str());
+
+  return (std::string)(*attr_ptr);
+}
+
+void Element::remove_attribute(const std::string& key)
+{
+  (*this)->removeAttribute(key.c_str());
+}
+
+std::string Element::get_value() const
+{
+  auto* input_el      = static_cast<client::HTMLInputElement*>(**this);
+  auto* client_string = input_el->get_value();
+
+  return (std::string)(*client_string);
+}
+
+std::string Element::get_text() const
+{
+  auto* client_string = (*this)->get_innerText();
+
+  return (std::string)(*client_string);
+}
+
+std::string Element::get_inner_html() const
+{
+  auto* client_string = (*this)->get_innerHTML();
+
+  return (std::string)(*client_string);
+}