comet-cpp 0.9.0

data/vendor/src/local_storage.hpp

@@ -0,0 +1,53 @@
+#ifndef  FRONT_LOCAL_STORAGE_HPP
+# define FRONT_LOCAL_STORAGE_HPP
+
+# include "from_string.hpp"
+# include "signal.hpp"
+# include <cheerp/clientlib.h>
+
+namespace Comet
+{
+  class LocalStorage
+  {
+  public:
+    LocalStorage();
+    LocalStorage(client::Storage*);
+    ~LocalStorage();
+
+    struct Change
+    {
+      Change(client::StorageEvent*);
+      Change() {}
+      std::string key, old_value, new_value;
+    };
+
+    Signal<Change> on_change;
+
+    template<typename T>
+    void set_item(const std::string& key, T value)
+    {
+      set_item<const std::string&>(key, std::to_string(value));
+    }
+
+    template<typename T>
+    T get_item(const std::string& key) const
+    {
+      return Comet::from_string<T>(get_item<std::string>(key));
+    }
+
+    void remove_item(const std::string& key);
+    void clear();
+
+  private:
+    void initialize();
+
+    client::Storage*       storage;
+    client::EventListener* event_listener;
+  };
+
+  template<> void LocalStorage::set_item<const std::string&>(const std::string& key, const std::string& value);
+  template<> void LocalStorage::set_item<std::string>(const std::string& key, std::string value);
+  template<> std::string LocalStorage::get_item<std::string>(const std::string& key) const;
+}
+
+#endif

data/vendor/src/mvc/collection.hpp

@@ -0,0 +1,154 @@
+#ifndef  COMET_MVC_COLLECTION_HPP
+# define COMET_MVC_COLLECTION_HPP
+
+# include "../signal.hpp"
+# include "../http.hpp"
+# include "../datatree.hpp"
+# include "model.hpp"
+# include <map>
+# include <list>
+
+namespace Comet
+{
+  template<typename MODEL>
+  class Collection : public Listener
+  {
+    typedef std::shared_ptr<MODEL> ModelPtr;
+    typedef std::map<typename MODEL::id_type, ModelPtr> Map;
+  public:
+    typedef MODEL Model;
+
+    Signal<MODEL&> added;
+    Signal<MODEL&> removed;
+    Signal<MODEL&> changed;
+    Signal<void>   synced;
+
+    virtual std::string get_url() const = 0;
+    virtual std::string get_mimetype() const = 0;
+
+    void add(ModelPtr model)
+    {
+      auto it = models.at(model->get_id());
+
+      if (it == models.end())
+      {
+        models.emplace(model->get_id(), model);
+        added.trigger(*model);
+      }
+    }
+
+    void remove(ModelPtr model)
+    {
+      auto it = models.at(model->get_id());
+
+      if (it != models.end())
+      {
+        models.erase(it);
+        removed.trigger(*model);
+      }
+    }
+
+    void each(std::function<void (ModelPtr)> callback)
+    {
+      for (auto item : models)
+        callback(item.second);
+    }
+
+    std::list<ModelPtr> where(std::function<bool (ModelPtr)> selector) const
+    {
+      std::list<ModelPtr> results;
+
+      for (auto item : models)
+      {
+        if (selector(item.second))
+          results.push_back(item.second);
+      }
+      return results;
+    }
+
+    ModelPtr find(std::function<bool (ModelPtr)> selector) const
+    {
+      for (auto item : models)
+      {
+        if (selector(item.second))
+          return item.second;
+      }
+      return nullptr;
+    }
+
+    ModelPtr get(typename MODEL::id_type id)
+    {
+      auto it = models.find(id);
+
+      if (it != models.end())
+        return it->second;
+      return nullptr;
+    }
+
+    Promise fetch()
+    {
+      auto request = Http::Request::get(get_url());
+        
+      request->set_headers({{"Accept", get_mimetype()}});
+      return request->send().then([this, request]()
+      {
+        auto response = request->get_response();
+          
+        if (response->ok())
+        {
+          if (response->has_body())
+            parse(response->get_response_text());
+          synced.trigger();
+        }
+      });
+    }
+
+    unsigned int count() const
+    {
+      return models.size();
+    }
+
+  protected:
+    virtual void parse(const std::string& str) = 0;
+
+    Map models;
+  };
+
+  template<typename MODEL>
+  class JsonCollection : public Collection<MODEL>
+  {
+  public:
+    virtual std::string get_mimetype() const
+    {
+      return "application/json";
+    }
+
+    virtual std::string get_resource_name() const
+    {
+      return "";
+    }
+
+  protected:
+    virtual void parse(const std::string& str)
+    {
+      DataTree   payload;
+      Data       models_json;
+      const auto resource_name = get_resource_name();
+
+      payload.from_json(str);
+      if (resource_name.length() == 0)
+        models_json = payload.as_data();
+      else
+        models_json = payload[resource_name];
+      models_json.each([this](Data model_json) -> bool
+      {
+        auto ptr = std::make_shared<MODEL>();
+        ptr->from_json(model_json);
+        Collection<MODEL>::models.emplace(ptr->get_id(), ptr);
+        return true;
+      });
+    }
+  };
+}
+
+#endif

data/vendor/src/mvc/controller.hpp

@@ -0,0 +1,59 @@
+#ifndef  COMET_MVC_CONTROLLER_HPP
+# define COMET_MVC_CONTROLLER_HPP
+
+# include "../promise.hpp"
+# include "../http.hpp"
+# include "../router.hpp"
+# include "layout.hpp"
+
+# define match_route(ROUTE, CONTROLLER, METHOD) \
+  match(ROUTE, [](const Params& p) \
+  { \
+    auto* controller = new CONTROLLER(p); \
+    controller->initialize().then([controller]() \
+    { \
+      controller->METHOD(); \
+      controller->finalize().then([controller]() { delete controller; }); \
+    }); \
+  });
+
+namespace Comet
+{
+  class Controller
+  {
+  protected:
+    const Params& params;
+
+  public:
+    Controller(const Params& p) : params(p)
+    {
+    }
+
+    virtual std::string get_application_name()
+    {
+      return "main";
+    }
+
+    template<typename ELEMENT>
+    Layout<ELEMENT>& use_layout()
+    {
+      auto& layout = get_layout<ELEMENT>();
+
+      layout.attach_as_layout(get_application_name());
+      return layout;
+    }
+
+    template<typename ELEMENT>
+    Layout<ELEMENT>& get_layout()
+    {
+      static Layout<ELEMENT> layout;
+
+      return layout;
+    }
+
+    Comet::Promise initialize() { return Promise::solved_promise(); }
+    Comet::Promise finalize()   { return Promise::solved_promise(); }
+  };
+}
+
+#endif

data/vendor/src/mvc/id_type.hpp

@@ -0,0 +1,9 @@
+#ifndef  COMET_MVC_ID_TYPE_HPP
+# define COMET_MVC_ID_TYPE_HPP
+
+# ifndef COMET_MVC_ID_TYPE
+#  define COMET_MVC_ID_TYPE unsigned long
+#  define COMET_MVC_NULL_ID 0
+# endif
+
+#endif

data/vendor/src/mvc/layout.hpp

@@ -0,0 +1,44 @@
+#ifndef  COMET_MVC_LAYOUT_HPP
+# define COMET_MVC_LAYOUT_HPP
+
+# include "../globals.hpp"
+# include "../exception.hpp"
+
+namespace Comet
+{
+  template<typename ELEMENT>
+  class Layout : public ELEMENT
+  {
+    Element get_container(const std::string& application_name)
+    {
+      auto candidates = body.find("[comet-app='" + application_name + "']");
+
+      if (candidates.size() > 0)
+        return candidates[0];
+      return body;
+    }
+
+  public:
+    void attach_as_layout(const std::string& application_name)
+    {
+      auto container = get_container(application_name);
+
+      if (container.is_undefined())
+        raise(std::runtime_error("Could not find the application container element"));
+      container.empty();
+      ELEMENT::append_to(container);
+      ELEMENT::bind_attributes();
+      ELEMENT::trigger_binding_updates();
+    }
+
+    template<typename VIEW_ELEMENT>
+    void render(std::shared_ptr<VIEW_ELEMENT> el)
+    {
+      ELEMENT::slot_content.set_element(el);
+      ELEMENT::bind_attributes();
+      ELEMENT::trigger_binding_updates();
+    }
+  };
+}
+
+#endif

data/vendor/src/mvc/model.cpp

@@ -0,0 +1,89 @@
+#include "model.hpp"
+#include "../http.hpp"
+
+using namespace Comet;
+using namespace std;
+
+Comet::Promise Model::fetch()
+{
+  auto request = Http::Request::get(get_url());
+
+  request->set_headers({{"Accept", get_content_type()}});
+  return request->send().then([this, request]()
+  {
+    auto response = request->get_response();
+
+    if (response->ok())
+    {
+      if (response->has_body())
+        parse(response->get_response_text());
+      synced.trigger();
+    }
+  });
+}
+
+Comet::Promise Model::save()
+{
+  auto request = Http::Request::make(get_id() == COMET_MVC_NULL_ID ? "post" : "put", get_url());
+  
+  request->set_headers({
+    {"Content-Type", get_content_type()},
+    {"Accept",       get_content_type()}
+  });
+  request->set_body(get_payload());
+  return request->send().then([this, request]()
+  {
+    auto response = request->get_response();
+    
+    if (response->ok())
+    {
+      if (response->has_body())
+        parse(response->get_response_text());
+      synced.trigger();
+    }
+  });
+}
+
+Comet::Promise Model::destroy(Comet::HttpResponseCallback callback)
+{
+  auto request = Http::Request::_delete(get_url());
+
+  request->set_headers({{"Accept", get_content_type()}});
+  return request->send().then([this, request, callback]()
+  {
+    auto response = request->get_response();
+
+    if (response->ok())
+      removed.trigger();
+    if (callback)
+      callback(response);
+  });
+}
+
+std::string JsonModel::get_payload()
+{
+  if (get_resource_name().length() > 0)
+  {
+    std::stringstream stream;
+    stream << '{' << '"' << get_resource_name() << '"' << ':' << to_json() << '}';
+
+    return stream.str();
+  }
+  return to_json();
+}
+
+void JsonModel::parse(const std::string& str)
+{
+  DataTree data;
+
+  data.from_json(str);
+  if (get_resource_name().length() > 0 && data[get_resource_name()].exists())
+    from_json(data[get_resource_name()]);
+  else
+    from_json(data);
+}
+
+std::string JsonModel::get_content_type() const
+{
+  return "application/json";
+}

data/vendor/src/mvc/model.hpp

@@ -0,0 +1,50 @@
+#ifndef  COMET_MVC_MODEL_HPP
+# define COMET_MVC_MODEL_HPP
+
+# include "../signal.hpp"
+# include "../promise.hpp"
+# include "../datatree.hpp"
+# include "id_type.hpp"
+
+namespace Comet
+{
+  namespace Http { class Response; }
+  typedef std::function<void (std::shared_ptr<Http::Response>)> HttpResponseCallback;
+
+  class Model : public Listener
+  {
+  public:
+    typedef COMET_MVC_ID_TYPE id_type;
+
+    Signal<void> removed;
+    Signal<void> synced;
+
+    virtual id_type     get_id() const { return id; }
+    virtual std::string get_url() const = 0;
+    virtual std::string get_resource_name() const { return ""; }
+
+    Promise fetch();
+    Promise save();
+    Promise destroy(HttpResponseCallback callback = HttpResponseCallback());
+    virtual void parse(const std::string& str) = 0;
+
+  protected:
+    virtual std::string get_payload() = 0;
+    virtual std::string get_content_type() const = 0;
+
+    id_type id = COMET_MVC_NULL_ID;
+  };
+
+  class JsonModel : public Model
+  {
+  public:
+    virtual void from_json(Data) = 0;
+    virtual std::string to_json() const = 0;
+    void parse(const std::string& str);
+  protected:
+    std::string get_payload();
+    std::string get_content_type() const;
+  };
+}
+
+#endif

data/vendor/src/object.cpp

@@ -0,0 +1,71 @@
+#include "object.hpp"
+#include "globals.hpp"
+
+using namespace Comet;
+using namespace std;
+
+static void prepare_is_undefined()
+{
+  static bool is_prepared = false;
+  
+  if (!is_prepared)
+  {
+    client::eval("window.isUndefined = function(a) { return a == undefined ? 'y' : 'n'; };");
+    is_prepared = true;
+  }
+}
+
+bool Object::is_of_type(const char* type) const
+{
+  if (is_undefined())
+    return false;
+  return ptr->operator[]("constructor") == *(window[type]);
+}
+
+bool Object::is_undefined() const
+{
+  prepare_is_undefined();
+  if (ptr != nullptr)
+  {
+    Object      answer = window.apply("isUndefined", *this);
+    std::string result = (std::string)(*static_cast<client::String*>(answer.ptr));
+    return result == "y";
+  }
+  return true;
+}
+
+void Object::set_global(const std::string& key, Object object)
+{
+  window.set(key, object);
+}
+
+template<>
+vector<wstring> Object::to_vector() const
+{
+  vector<wstring> result;
+
+  if (is_of_type("Array"))
+  {
+    const client::Array& array = *(static_cast<client::Array*>(ptr));
+    result.resize(array.get_length());
+    for (int i = 0 ; i < array.get_length() ; ++i)
+      result.push_back((wstring)(Object(array[i])));
+  }
+  return result;
+}
+
+namespace Comet
+{
+  std::wstring to_wstring(client::String* value)
+  {
+    std::wstring wide_string;
+    auto         length = value->get_length();
+    wchar_t*     result = new wchar_t[length + 1];
+
+    for(int i = 0; i < value->get_length() ; i++)
+      result[i] = (wchar_t)value->charCodeAt(i);
+    wide_string = std::wstring(result, length);
+    delete[] result;
+    return wide_string;
+  }
+}